LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41cd2(%rip), %r12     # 0x55490
callq 0x152bc
testq %rax, %rax
je 0x138d9
movq %rax, %r14
movss (%rax), %xmm0
movl 0x17d8(%r12), %r13d
movl 0x17dc(%r12), %eax
cmpl %eax, %r13d
jne 0x13890
incl %r13d
testl %eax, %eax
je 0x13800
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x13805
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x13890
movss %xmm0, -0x2c(%rbp)
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
testq %rdi, %rdi
je 0x1386e
movq 0x41c28(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x41c1b(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x17e0(%r12)
movl %r13d, 0x17dc(%r12)
movss -0x2c(%rbp), %xmm0
movq 0x17e0(%r12), %rax
movslq 0x17d8(%r12), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x17d8(%r12)
leaq (%rcx,%rcx,2), %rcx
movl %ebx, (%rax,%rcx,4)
movss %xmm0, 0x4(%rax,%rcx,4)
movl $0x0, 0x8(%rax,%rcx,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 0x2a560(%rip), %rdi     # 0x3de40
leaq 0x29d9e(%rip), %rsi     # 0x3d685
leaq 0x2a561(%rip), %rcx     # 0x3de4f
movl $0x10e2, %edx           # imm = 0x10E2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13971
movq 0x41b6b(%rip), %rax     # 0x55490
leaq 0x1460(%rax), %rcx
incl %edi
movslq 0x17c8(%rax), %rdx
testq %rdx, %rdx
jle 0x13992
movq 0x17d0(%rax), %rsi
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 0x13973
decl %edx
movl %edx, 0x17c8(%rax)
decl %edi
cmpl $0x1, %edi
jg 0x1392e
popq %rbp
retq
leaq 0x3323b(%rip), %rdi     # 0x46bb5
leaq 0x2b112(%rip), %rsi     # 0x3ea93
leaq 0x2bc64(%rip), %rcx     # 0x3f5ec
movl $0x338, %edx            # imm = 0x338
callq 0x7140
leaq 0x3321c(%rip), %rdi     # 0x46bb5
leaq 0x2b0f3(%rip), %rsi     # 0x3ea93
leaq 0x2bc09(%rip), %rcx     # 0x3f5b0
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41ad1(%rip), %r14     # 0x55490
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x8794
movslq 0x1738(%r14), %rcx
testq %rcx, %rcx
jle 0x139f2
movq 0x1740(%r14), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rbx
cmpl %eax, 0x8(%rbx)
je 0x139f2
incq %rsi
cmpq %rsi, %rcx
jne 0x139df
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41a06(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm0
movss 0x8(%rdi), %xmm4
movss 0xc(%rdi), %xmm2
testl %esi, %esi
je 0x13ae8
movss 0x1e0(%rax), %xmm3
movss 0x1e4(%rax), %xmm5
maxss %xmm1, %xmm3
maxss %xmm0, %xmm5
movss 0x1e8(%rax), %xmm0
minss %xmm4, %xmm0
movss 0x1ec(%rax), %xmm1
minss %xmm2, %xmm1
movaps %xmm1, %xmm2
movaps %xmm0, %xmm4
movaps %xmm5, %xmm0
movaps %xmm3, %xmm1
movaps %xmm4, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm5
andps %xmm1, %xmm5
andnps %xmm4, %xmm3
orps %xmm5, %xmm3
ucomiss %xmm1, %xmm3
jb 0x13b63
movaps %xmm2, %xmm4
cmpless %xmm0, %xmm4
movaps %xmm4, %xmm5
andps %xmm0, %xmm5
andnps %xmm2, %xmm4
orps %xmm5, %xmm4
ucomiss %xmm0, %xmm4
jb 0x13b63
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 0x2d48c
addq $0x10, %rsp
popq %rbp
retq
leaq 0x2b15b(%rip), %rdi     # 0x3ecc5
leaq 0x29b14(%rip), %rsi     # 0x3d685
leaq 0x2b17a(%rip), %rcx     # 0x3ecf2
movl $0x8cd, %edx            # imm = 0x8CD
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4093a(%rip), %rbx     # 0x55490
cmpb $0x1, 0x2be8(%rbx)
jne 0x14bd3
leaq 0x2c952(%rip), %rdi     # 0x414b8
xorl %eax, %eax
callq 0xe031
movb $0x0, 0x2be8(%rbx)
movq 0x2bf0(%rbx), %rdi
testq %rdi, %rdi
je 0x14ba3
movq 0x40449(%rip), %rax     # 0x54fd0
cmpq (%rax), %rdi
je 0x14b93
callq 0x7340
jmp 0x14b98
callq 0x73b0
movq $0x0, 0x2bf0(%rbx)
movq 0x2bf8(%rbx), %rax
cmpl $0x3, (%rax)
jl 0x14bd3
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
je 0x14bc1
movq 0x8(%rax), %rdi
callq *%rcx
movq 0x2bf8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24a4e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x408a4(%rip), %rbx     # 0x55490
movq 0x1758(%rbx), %r14
movss 0x11c(%r14), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x14c47
movaps %xmm1, -0x20(%rbp)
callq 0xb0a3
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 0x28740(%rip), %xmm0    # 0x3d380
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_O1/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 0x40824(%rip), %r15     # 0x55490
testq %rdi, %rdi
jne 0x14c89
movq 0x90(%r15), %rax
cmpl $0x0, 0x30(%rax)
jle 0x14d73
movq 0x38(%rax), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0xc197
movl 0x17e8(%r15), %r12d
movl 0x17ec(%r15), %eax
cmpl %eax, %r12d
jne 0x14d38
incl %r12d
testl %eax, %eax
je 0x14cbc
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x14cc1
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x14d38
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x407b5(%rip), %rax     # 0x55490
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
testq %rdi, %rdi
je 0x14d1d
movq 0x40779(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4076c(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r14, 0x17f0(%r15)
movl %r12d, 0x17ec(%r15)
movq 0x17f0(%r15), %rax
movslq 0x17e8(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x17e8(%r15)
movq %rbx, (%rax,%rcx,8)
movq 0x1758(%r15), %rax
movq 0x270(%rax), %rdi
movq 0x30(%rbx), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d60a
leaq 0x2a036(%rip), %rdi     # 0x3edb0
leaq 0x29d12(%rip), %rsi     # 0x3ea93
leaq 0x2a4d1(%rip), %rcx     # 0x3f259
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x406f1(%rip), %rbx     # 0x55490
movq 0x1758(%rbx), %rax
movq 0x270(%rax), %rdi
callq 0x2d6a6
movl 0x17e8(%rbx), %eax
testl %eax, %eax
jle 0x14dff
movl %eax, %ecx
decl %ecx
movl %ecx, 0x17e8(%rbx)
je 0x14de0
cmpl $0x1, %eax
je 0x14e1e
movq 0x17f0(%rbx), %rax
movl %ecx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
jmp 0x14df1
movq 0x90(%rbx), %rax
cmpl $0x0, 0x30(%rax)
jle 0x14e3d
movq 0x38(%rax), %rax
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc197
leaq 0x31daf(%rip), %rdi     # 0x46bb5
leaq 0x29c86(%rip), %rsi     # 0x3ea93
leaq 0x2a6da(%rip), %rcx     # 0x3f4ee
movl $0x338, %edx            # imm = 0x338
callq 0x7140
leaq 0x31d90(%rip), %rdi     # 0x46bb5
leaq 0x29c67(%rip), %rsi     # 0x3ea93
leaq 0x2a6ee(%rip), %rcx     # 0x3f521
movl $0x326, %edx            # imm = 0x326
callq 0x7140
leaq 0x29f6c(%rip), %rdi     # 0x3edb0
leaq 0x29c48(%rip), %rsi     # 0x3ea93
leaq 0x2a407(%rip), %rcx     # 0x3f259
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15317
movq 0x401c2(%rip), %rcx     # 0x55490
movl %edi, %edx
leaq 0x281cd(%rip), %rsi     # 0x3d4a4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
addq $0x13e8, %rcx           # imm = 0x13E8
jmp 0x15314
addq $0x1404, %rcx           # imm = 0x1404
jmp 0x15314
addq $0x1440, %rcx           # imm = 0x1440
jmp 0x15314
addq $0x13fc, %rcx           # imm = 0x13FC
jmp 0x15314
addq $0x1410, %rcx           # imm = 0x1410
jmp 0x15314
addq $0x1430, %rcx           # imm = 0x1430
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    ImGuiState& g = *GImGui;
    ImVec2* pvar = GetStyleVarVec2Addr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = *pvar;
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %r14d
movq 0x4015c(%rip), %r12     # 0x55490
xorl %r13d, %r13d
leal -0x1(%r14), %eax
cmpl $0x7, %eax
ja 0x15380
leaq 0x28189(%rip), %rcx     # 0x3d4d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13ec(%r12), %r13
jmp 0x15380
leaq 0x1408(%r12), %r13
jmp 0x15380
leaq 0x13f4(%r12), %r13
jmp 0x15380
leaq 0x1414(%r12), %r13
jmp 0x15380
leaq 0x141c(%r12), %r13
testq %r13, %r13
je 0x154a8
movss (%r13), %xmm0
movss 0x4(%r13), %xmm1
movl 0x17d8(%r12), %ebx
movl 0x17dc(%r12), %eax
cmpl %eax, %ebx
jne 0x15463
incl %ebx
testl %eax, %eax
je 0x153c0
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x153c5
movl $0x8, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl %ebx, %eax
jge 0x15463
movss %xmm1, -0x2c(%rbp)
movss %xmm0, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movslq %ebx, %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
testq %rdi, %rdi
je 0x15438
movq 0x4005e(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x40051(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x17e0(%r12)
movl %ebx, 0x17dc(%r12)
movq -0x38(%rbp), %rsi
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movq 0x17e0(%r12), %rax
movslq 0x17d8(%r12), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x17d8(%r12)
leaq (%rcx,%rcx,2), %rcx
movl %r14d, (%rax,%rcx,4)
movss %xmm0, 0x4(%rax,%rcx,4)
movss %xmm1, 0x8(%rax,%rcx,4)
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28991(%rip), %rdi     # 0x3de40
leaq 0x281cf(%rip), %rsi     # 0x3d685
leaq 0x289c1(%rip), %rcx     # 0x3de7e
movl $0x10ef, %edx           # imm = 0x10EF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowPos(ImGuiWindow*, ImVec2 const&, int)
static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;
    window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
    window->SetWindowPosCenterWanted = false;

    // Set
    const ImVec2 old_pos = window->Pos;
    window->PosFloat = pos;
    window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
    window->DC.CursorPos += (window->Pos - old_pos);    // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += (window->Pos - old_pos); // And more importantly we need to adjust this so size calculation doesn't get affected.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
je 0x1562e
testl %edx, 0x94(%rdi)
je 0x156bd
andb $-0xf, 0x94(%rdi)
movb $0x0, 0xa0(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movaps %xmm0, %xmm2
subss 0x18(%rdi), %xmm2
movss %xmm0, 0x18(%rdi)
movaps %xmm1, %xmm0
subss 0x1c(%rdi), %xmm0
movss %xmm1, 0x1c(%rdi)
movss 0xa8(%rdi), %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0xa8(%rdi)
movss 0xac(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xac(%rdi)
addss 0xc0(%rdi), %xmm2
movss %xmm2, 0xc0(%rdi)
addss 0xc4(%rdi), %xmm0
movss %xmm0, 0xc4(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFocus(char const*)
void ImGui::SetWindowFocus(const char* name)
{
    if (name)
    {
        ImGuiWindow* window = FindWindowByName(name);
        if (window)
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x157f0
pushq %rbp
movq %rsp, %rbp
callq 0x139b1
testq %rax, %rax
popq %rbp
je 0x15802
movq %rax, %rdi
jmp 0xd00c
movq 0x3fc99(%rip), %rax     # 0x55490
movq $0x0, 0x1770(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetColumnOffset(int)
float ImGui::GetColumnOffset(int column_index)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    if (g.ActiveId)
    {
        const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
        if (g.ActiveId == column_id)
            return GetDraggedColumnOffset(column_index);
    }

    // Read from cache
    IM_ASSERT(column_index < window->DC.ColumnsOffsetsT.Size);
    const float t = window->DC.ColumnsOffsetsT[column_index];

    const float content_region_width = window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x;
    const float min_x = window->DC.ColumnsStartX;
    const float max_x = content_region_width - window->Scroll.x - ((window->Flags & ImGuiWindowFlags_NoScrollbar) ? 0 : g.Style.ScrollbarSize);// - window->WindowPadding().x;
    const float x = min_x + t * (max_x - min_x);
    return (float)(int)x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x3fb9c(%rip), %r14     # 0x55490
movq 0x1758(%r14), %r15
testl %edi, %edi
jns 0x15906
movl 0x19c(%r15), %ebx
movl 0x1790(%r14), %r12d
testl %r12d, %r12d
je 0x1592d
movl 0x1b8(%r15), %r13d
addl %ebx, %r13d
cmpl %r13d, %r12d
jne 0x15928
movl %ebx, %edi
callq 0x22928
cmpl %r13d, %r12d
je 0x15991
cmpl 0x1c0(%r15), %ebx
jge 0x159a0
movq 0x1c8(%r15), %rax
movslq %ebx, %rcx
movss 0x38(%r15), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x15956
jp 0x15956
movss 0x20(%r15), %xmm0
movss (%rax,%rcx,4), %xmm2
movss 0x194(%r15), %xmm3
subss 0x4c(%r15), %xmm0
testb $0x8, 0xc(%r15)
jne 0x1597a
movss 0x1438(%r14), %xmm1
subss %xmm1, %xmm0
subss %xmm3, %xmm0
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28e4e(%rip), %rdi     # 0x3e7f5
leaq 0x27cd7(%rip), %rsi     # 0x3d685
leaq 0x28e6f(%rip), %rcx     # 0x3e824
movl $0x21e0, %edx           # imm = 0x21E0
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFontScale(float)
void ImGui::SetWindowFontScale(float scale)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3f8e6(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss %xmm0, 0x268(%rcx)
mulss 0x171c(%rax), %xmm0
movss %xmm0, 0x1718(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextV(char const*, __va_list_tag*)
void ImGui::TextV(const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    TextUnformatted(g.TempBuffer, text_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3f451(%rip), %r14     # 0x55490
movq 0x1758(%r14), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x16055
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %rcx
movq %rdi, %rdx
leaq 0x2df2(%r14), %rbx
movl $0xc01, %esi            # imm = 0xC01
movq %rbx, %rdi
callq 0x74e0
movb $0x0, 0x39f2(%r14)
cmpl $-0x1, %eax
movl $0xc01, %ecx            # imm = 0xC01
cmovnel %eax, %ecx
movslq %ecx, %rax
leaq (%r14,%rax), %rsi
addq $0x2df2, %rsi           # imm = 0x2DF2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd93a
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextColored(ImVec4 const&, char const*, ...)
void ImGui::TextColored(const ImVec4& col, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    TextColoredV(col, fmt, args);
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0xe0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1619f
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
xorl %edi, %edi
callq 0x1367a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16031
movl $0x1, %edi
callq 0x13916
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextWrapped(char const*, ...)
void ImGui::TextWrapped(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    TextWrappedV(fmt, args);
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1631a
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
xorps %xmm0, %xmm0
callq 0x15132
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16031
callq 0x1522a
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::AlignFirstTextHeightToWidgets()
void ImGui::AlignFirstTextHeightToWidgets()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    // Declare a dummy item size to that upcoming items that are smaller will center-align on the newly expanded line height.
    ImGuiState& g = *GImGui;
    ItemSize(ImVec2(0, g.FontSize + g.Style.FramePadding.y*2), g.Style.FramePadding.y);
    ImGui::SameLine(0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3f126(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x163eb
movss 0x140c(%rax), %xmm0
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
addss 0x1718(%rax), %xmm1
leaq -0x8(%rbp), %rdi
movl $0x0, (%rdi)
movss %xmm1, 0x4(%rdi)
callq 0xaab7
movq 0x3f0e3(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x163eb
xorps %xmm0, %xmm0
addss 0xb0(%rax), %xmm0
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm0, 0xa8(%rax)
movl %ecx, 0xac(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float local_pos_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    float x, y;
    if (local_pos_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        x = window->Pos.x - window->Scroll.x + local_pos_x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        x = window->DC.CursorPosPrevLine.x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrentLineHeight = window->DC.PrevLineHeight;
    window->DC.CurrentLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
    window->DC.CursorPos = ImVec2(x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3f094(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x16466
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x16417
jnp 0x1642f
maxss %xmm1, %xmm2
movss 0x18(%rax), %xmm1
subss 0x4c(%rax), %xmm1
addss %xmm0, %xmm1
addss %xmm2, %xmm1
jmp 0x16444
ucomiss %xmm1, %xmm2
jbe 0x1643c
movss 0x1414(%rcx), %xmm1
addss 0xb0(%rax), %xmm1
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm1, 0xa8(%rax)
movl %ecx, 0xac(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SmallButton(char const*)
bool ImGui::SmallButton(const char* label)
{
    ImGuiState& g = *GImGui;
    float backup_padding_y = g.Style.FramePadding.y;
    g.Style.FramePadding.y = 0.0f;
    bool pressed = ButtonEx(label, ImVec2(0,0), ImGuiButtonFlags_AlignTextBaseLine);
    g.Style.FramePadding.y = backup_padding_y;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x3eb9e(%rip), %rbx     # 0x55490
movss 0x140c(%rbx), %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, 0x140c(%rbx)
leaq -0x14(%rbp), %rsi
movq $0x0, (%rsi)
movl $0x40, %edx
callq 0x166bc
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x140c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InvisibleButton(char const*, ImVec2 const&)
bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    const ImGuiID id = window->GetID(str_id);
    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(bb);
    if (!ItemAdd(bb, &id))
        return false;

    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, true);

    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x3eb48(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
je 0x16962
xorl %ebx, %ebx
jmp 0x16a13
movq %rsi, %r12
movq %rdi, %rsi
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
callq 0xa872
leaq -0x28(%rbp), %r14
movl %eax, (%r14)
movsd (%r12), %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0xafbc
movss 0xa8(%r15), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0xac(%r15), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq 0xa8(%r15), %rax
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
movlps %xmm1, 0x8(%r15)
movss 0x8(%r15), %xmm0
movss 0xc(%r15), %xmm1
subss (%r15), %xmm0
subss 0x4(%r15), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x30(%rbp), %rdi
movlps %xmm0, (%rdi)
xorps %xmm0, %xmm0
callq 0xaab7
movq %r15, %rdi
movq %r14, %rsi
callq 0xac09
testb %al, %al
je 0x16a13
movl -0x28(%rbp), %esi
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x21(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x13d8d
movl %eax, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToTTY(int)
void ImGui::LogToTTY(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = stdout;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3e47d(%rip), %rax     # 0x55490
cmpb $0x0, 0x2be8(%rax)
jne 0x17051
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
movq 0x3df9f(%rip), %rdx     # 0x54fd0
movq (%rdx), %rdx
movq %rdx, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x17051
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToFile(int, char const*)
void ImGui::LogToFile(int max_depth, const char* filename)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    if (!filename)
    {
        filename = g.IO.LogFilename;
        if (!filename)
            return;
    }

    g.LogFile = fopen(filename, "ab");
    if (!g.LogFile)
    {
        IM_ASSERT(g.LogFile != NULL); // Consider this an error
        return;
    }
    g.LogEnabled = true;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x3e42c(%rip), %r14     # 0x55490
cmpb $0x0, 0x2be8(%r14)
jne 0x170c4
movl %edi, %ebx
movq 0x1758(%r14), %r15
testq %rsi, %rsi
jne 0x17085
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x170c4
leaq 0x26ec6(%rip), %rax     # 0x3df52
movq %rsi, %rdi
movq %rax, %rsi
callq 0x78d0
movq %rax, 0x2bf0(%r14)
testq %rax, %rax
je 0x170cf
movb $0x1, 0x2be8(%r14)
movl 0xdc(%r15), %eax
movl %eax, 0x2c00(%r14)
testl %ebx, %ebx
js 0x170c4
movl %ebx, 0x2c04(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x270bd(%rip), %rdi     # 0x3e193
leaq 0x265a8(%rip), %rsi     # 0x3d685
leaq 0x270c3(%rip), %rcx     # 0x3e1a7
movl $0x14e4, %edx           # imm = 0x14E4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToClipboard(int)
void ImGui::LogToClipboard(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = NULL;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3e397(%rip), %rax     # 0x55490
cmpb $0x0, 0x2be8(%rax)
jne 0x17131
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
movq $0x0, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x17131
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderInt(char const*, int*, int, int, char const*)
bool ImGui::SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format)
{
    if (!display_format)
        display_format = "%.0f";
    float v_f = (float)*v;
    bool value_changed = ImGui::SliderFloat(label, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
    *v = (int)v_f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %r8, %r8
leaq 0x29a39(%rip), %rax     # 0x40efb
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm0
movss %xmm1, (%r14)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss 0x25e9a(%rip), %xmm2    # 0x3d380
movq %r14, %rsi
movq %rax, %rdx
callq 0x1b0db
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeBehaviorIsOpened(unsigned int, int)
bool ImGui::TreeNodeBehaviorIsOpened(ImGuiID id, ImGuiTreeNodeFlags flags)
{
    // We only write to the tree storage if the user clicks (or explicitely use SetNextTreeNode*** functions)
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiStorage* storage = window->DC.StateStorage;

    bool opened;
    if (g.SetNextTreeNodeOpenedCond != 0)
    {
        if (g.SetNextTreeNodeOpenedCond & ImGuiSetCond_Always)
        {
            opened = g.SetNextTreeNodeOpenedVal;
            storage->SetInt(id, opened);
        }
        else
        {
            // We treat ImGuiSetCondition_Once and ImGuiSetCondition_FirstUseEver the same because tree node state are not saved persistently.
            const int stored_value = storage->GetInt(id, -1);
            if (stored_value == -1)
            {
                opened = g.SetNextTreeNodeOpenedVal;
                storage->SetInt(id, opened);
            }
            else
            {
                opened = stored_value != 0;
            }
        }
        g.SetNextTreeNodeOpenedCond = 0;
    }
    else
    {
        opened = storage->GetInt(id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;
    }

    // When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).
    // NB- If we are above max depth we still allow manually opened nodes to be logged.
    if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoExpandOnLog) && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
        opened = true;

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r15d
movq 0x3df77(%rip), %r13     # 0x55490
movq 0x1758(%r13), %rbx
movq 0x110(%rbx), %r12
movl 0x1848(%r13), %eax
testl %eax, %eax
je 0x1757c
movl %esi, -0x2c(%rbp)
testb $0x1, %al
jne 0x17556
movq %r12, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x90c0
cmpl $-0x1, %eax
je 0x17556
testl %eax, %eax
setne %r14b
jmp 0x1756c
movb 0x1845(%r13), %r14b
movzbl %r14b, %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x9642
movl $0x0, 0x1848(%r13)
movl -0x2c(%rbp), %ecx
jmp 0x17598
movl %esi, %edx
andl $0x1, %edx
movq %r12, %rdi
movl %esi, %r14d
movl %r15d, %esi
callq 0x90c0
movl %r14d, %ecx
testl %eax, %eax
setne %r14b
testb $0x2, %cl
jne 0x175c2
cmpb $0x0, 0x2be8(%r13)
je 0x175c2
movl 0xdc(%rbx), %eax
cmpl 0x2c04(%r13), %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
movl %r14d, %eax
addq $0x8, %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.cpp
// Function: ImGui::Bullet()
void ImGui::Bullet()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float line_height = g.FontSize;
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(line_height, line_height));
    ItemSize(bb);
    if (!ItemAdd(bb, NULL))
    {
        ImGui::SameLine(0, -1);
        return;
    }

    // Render
    const float bullet_size = line_height*0.15f;
    window->DrawList->AddCircleFilled(bb.Min + ImVec2(style.FramePadding.x + line_height*0.5f, line_height*0.5f), bullet_size, window->Color(ImGuiCol_Text));

    // Stay on same line
    ImGui::SameLine(0, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x3d93d(%rip), %r14     # 0x55490
movq 0x1758(%r14), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
jne 0x17cc4
movss 0x1718(%r14), %xmm2
movss 0xa8(%r15), %xmm0
addss %xmm2, %xmm0
movss 0xac(%r15), %xmm1
movaps %xmm2, -0x40(%rbp)
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0xa8(%r15), %rax
leaq -0x68(%rbp), %rbx
movq %rax, (%rbx)
movlps %xmm0, 0x8(%rbx)
movss (%rbx), %xmm2
movss 0x4(%rbx), %xmm3
movss 0x8(%rbx), %xmm0
movss 0xc(%rbx), %xmm1
movaps %xmm2, -0x30(%rbp)
subss %xmm2, %xmm0
movss %xmm3, -0x20(%rbp)
subss %xmm3, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x50(%rbp), %rdi
movlps %xmm0, (%rdi)
xorps %xmm0, %xmm0
callq 0xaab7
movq %rbx, %rdi
xorl %esi, %esi
callq 0xac09
testb %al, %al
je 0x17c7a
movss 0x2582a(%rip), %xmm0    # 0x3d420
movaps -0x40(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
mulss 0x257b1(%rip), %xmm1    # 0x3d3bc
movq 0x270(%r15), %rbx
movss 0x1408(%r14), %xmm0
addss %xmm1, %xmm0
movaps -0x30(%rbp), %xmm2
addss %xmm0, %xmm2
addss -0x20(%rbp), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x58(%rbp), %r14
movlps %xmm2, (%r14)
movq 0x3d852(%rip), %rax     # 0x55490
movups 0x1460(%rax), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8cce
movq %rbx, %rdi
movq %r14, %rsi
movss -0x1c(%rbp), %xmm0
movl %eax, %edx
movl $0xc, %ecx
callq 0x30602
movq 0x3d80f(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x17cc4
movss 0x1414(%rcx), %xmm0
addss 0xb0(%rax), %xmm0
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm0, 0xa8(%rax)
movl %ecx, 0xac(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeV(char const*, char const*, __va_list_tag*)
bool ImGui::TreeNodeV(const char* str_id, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    if (!str_id || !str_id[0])
        str_id = fmt;

    ImGui::PushID(str_id);
    const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
    ImGui::PopID();

    if (opened)
        ImGui::TreePush(str_id);

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3d52e(%rip), %r12     # 0x55490
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x17f79
xorl %r14d, %r14d
jmp 0x17fe0
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2df2(%r12), %r14
movl $0xc01, %esi            # imm = 0xC01
movq %r14, %rdi
movq %r15, %rdx
callq 0x74e0
movb $0x0, 0x39f2(%r12)
testq %rbx, %rbx
je 0x17fad
cmpb $0x0, (%rbx)
jne 0x17fb0
movq %r15, %rbx
movq %rbx, %rdi
callq 0x173b3
leaq 0x294fa(%rip), %rsi     # 0x414b9
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x175d4
movl %eax, %r14d
callq 0x16fc0
testb %r14b, %r14b
je 0x17fe0
movq %rbx, %rdi
callq 0x17fec
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreePush(char const*)
void ImGui::TreePush(const char* str_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Indent();
    window->DC.TreeDepth++;
    PushID(str_id ? str_id : "#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3d499(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
incl 0xdc(%rcx)
testq %rdi, %rdi
leaq 0x2682f(%rip), %rax     # 0x3e86e
cmoveq %rax, %rdi
popq %rbp
jmp 0x173b3
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeV(void const*, char const*, __va_list_tag*)
bool ImGui::TreeNodeV(const void* ptr_id, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);

    if (!ptr_id)
        ptr_id = fmt;

    ImGui::PushID(ptr_id);
    const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
    ImGui::PopID();

    if (opened)
        ImGui::TreePush(ptr_id);

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3d3be(%rip), %r12     # 0x55490
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x180e9
xorl %r14d, %r14d
jmp 0x1814a
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2df2(%r12), %r15
movl $0xc01, %esi            # imm = 0xC01
movq %r15, %rdi
movq %r14, %rdx
callq 0x74e0
movb $0x0, 0x39f2(%r12)
testq %rbx, %rbx
cmoveq %r14, %rbx
movq %rbx, %rdi
callq 0x16ecb
leaq 0x29390(%rip), %rsi     # 0x414b9
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x175d4
movl %eax, %r14d
callq 0x16fc0
testb %r14b, %r14b
je 0x1814a
movq %rbx, %rdi
callq 0x18156
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreePush(void const*)
void ImGui::TreePush(const void* ptr_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Indent();
    window->DC.TreeDepth++;
    PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3d32f(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
incl 0xdc(%rcx)
testq %rdi, %rdi
leaq 0x266c5(%rip), %rax     # 0x3e86e
cmoveq %rax, %rdi
popq %rbp
jmp 0x16ecb
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ParseFormatPrecision(char const*, int)
int ImGui::ParseFormatPrecision(const char* fmt, int default_precision)
{
    int precision = default_precision;
    while ((fmt = strchr(fmt, '%')) != NULL)
    {
        fmt++;
        if (fmt[0] == '%') { fmt++; continue; } // Ignore "%%"
        while (*fmt >= '0' && *fmt <= '9')
            fmt++;
        if (*fmt == '.')
        {
            precision = atoi(fmt + 1);
            if (precision < 0 || precision > 10)
                precision = default_precision;
        }
        break;
    }
    return precision;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0x25, %esi
callq 0x7400
testq %rax, %rax
je 0x1a9d8
cmpb $0x25, 0x1(%rax)
jne 0x1a9b5
addq $0x2, %rax
movq %rax, %rdi
jmp 0x1a997
incq %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x1a9b8
cmpb $0x2e, %cl
jne 0x1a9d8
movq %rax, %rdi
callq 0x7240
cmpl $0xb, %eax
cmovbl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RoundScalar(float, int)
float ImGui::RoundScalar(float value, int decimal_precision)
{
    // Round past decimal precision
    // So when our value is 1.99999 with a precision of 0.001 we'll end up rounding to 2.0
    // FIXME: Investigate better rounding methods
    static const float min_steps[10] = { 1.0f, 0.1f, 0.01f, 0.001f, 0.0001f, 0.00001f, 0.000001f, 0.0000001f, 0.00000001f, 0.000000001f };
    float min_step = (decimal_precision >= 0 && decimal_precision < 10) ? min_steps[decimal_precision] : powf(10.0f, (float)-decimal_precision);
    bool negative = value < 0.0f;
    value = fabsf(value);
    float remainder = fmodf(value, min_step);
    if (remainder <= min_step*0.5f)
        value -= remainder;
    else
        value += (min_step - remainder);
    return negative ? -value : value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movaps %xmm0, -0x10(%rbp)
cmpl $0x9, %edi
ja 0x1aa02
movl %edi, %eax
leaq 0x22b65(%rip), %rcx     # 0x3d560
movss (%rcx,%rax,4), %xmm1
jmp 0x1aa18
negl %edi
cvtsi2ss %edi, %xmm1
movss 0x22a30(%rip), %xmm0    # 0x3d440
callq 0x7640
movaps %xmm0, %xmm1
movaps 0x228b1(%rip), %xmm0    # 0x3d2d0
andps -0x10(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0x78f0
movss 0x22984(%rip), %xmm1    # 0x3d3bc
movaps -0x20(%rbp), %xmm4
mulss %xmm4, %xmm1
subss %xmm0, %xmm4
movaps 0x228d5(%rip), %xmm2    # 0x3d320
movaps %xmm0, %xmm3
xorps %xmm2, %xmm3
cmpnless %xmm1, %xmm0
andps %xmm0, %xmm4
andnps %xmm3, %xmm0
orps %xmm4, %xmm0
addss -0x30(%rbp), %xmm0
xorps %xmm0, %xmm2
xorps %xmm1, %xmm1
movaps -0x10(%rbp), %xmm3
cmpltss %xmm1, %xmm3
movaps %xmm3, %xmm1
andnps %xmm0, %xmm1
andps %xmm2, %xmm3
orps %xmm1, %xmm3
movaps %xmm3, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderAngle(char const*, float*, float, float)
bool ImGui::SliderAngle(const char* label, float* v_rad, float v_degrees_min, float v_degrees_max)
{
    float v_deg = (*v_rad) * 360.0f / (2*IM_PI);
    bool value_changed = ImGui::SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, "%.0f deg", 1.0f);
    *v_rad = v_deg * (2*IM_PI) / 360.0f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movss (%rsi), %xmm2
mulss 0x21d3d(%rip), %xmm2    # 0x3d444
divss 0x21d39(%rip), %xmm2    # 0x3d448
leaq -0x14(%rbp), %r14
movss %xmm2, (%r14)
leaq 0x22bd2(%rip), %rdx     # 0x3e2f1
movss 0x21c59(%rip), %xmm2    # 0x3d380
movq %r14, %rsi
callq 0x1b0db
movss 0x21d11(%rip), %xmm0    # 0x3d448
mulss (%r14), %xmm0
divss 0x21d00(%rip), %xmm0    # 0x3d444
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::VSliderInt(char const*, ImVec2 const&, int*, int, int, char const*)
bool ImGui::VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format)
{
    if (!display_format)
        display_format = "%.0f";
    float v_f = (float)*v;
    bool value_changed = ImGui::VSliderFloat(label, size, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
    *v = (int)v_f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
testq %r9, %r9
leaq 0x25792(%rip), %rax     # 0x40efb
cmovneq %r9, %rax
cvtsi2ssl (%rdx), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %ecx, %xmm0
movss %xmm1, (%r14)
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
movss 0x21bf2(%rip), %xmm2    # 0x3d380
movq %r14, %rdx
movq %rax, %rcx
callq 0x1b462
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq