LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_discard_undo(ImGuiStb::StbUndoState*)
static void stb_textedit_discard_undo(StbUndoState *state)
{
   if (state->undo_point > 0) {
      // if the 0th undo state has characters, clean those up
      if (state->undo_rec[0].char_storage >= 0) {
         int n = state->undo_rec[0].insert_length, i;
         // delete n characters from all other records
         state->undo_char_point = state->undo_char_point - (short) n;  // vsnet05
         memmove(state->undo_char, state->undo_char + n, (size_t) ((size_t)state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE)));
         for (i=0; i < state->undo_point; ++i)
            if (state->undo_rec[i].char_storage >= 0)
               state->undo_rec[i].char_storage = state->undo_rec[i].char_storage - (short) n; // vsnet05 // @OPTIMIZE: get rid of char_storage and infer it
      }
      --state->undo_point;
      memmove(state->undo_rec, state->undo_rec+1, (size_t) ((size_t)state->undo_point*sizeof(state->undo_rec[0])));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movswl 0xc72(%rax), %eax
cmpl $0x0, %eax
jle 0x2c279
movq -0x8(%rbp), %rax
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jl 0x2c242
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movswl 0xc76(%rax), %eax
movl -0xc(%rbp), %ecx
movswl %cx, %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc76(%rax)
movq -0x8(%rbp), %rdi
addq $0x4a4, %rdi            # imm = 0x4A4
movq -0x8(%rbp), %rsi
addq $0x4a4, %rsi            # imm = 0x4A4
movslq -0xc(%rbp), %rax
shlq %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movswq 0xc76(%rax), %rdx
shlq %rdx
callq 0x7150
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0xc72(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2c240
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jl 0x2c233
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movswl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
movswl %cx, %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
jmp 0x2c235
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c1d8
jmp 0x2c242
movq -0x8(%rbp), %rax
movw 0xc72(%rax), %cx
addw $-0x1, %cx
movw %cx, 0xc72(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
movq -0x8(%rbp), %rax
movswq 0xc72(%rax), %rax
imulq $0xc, %rax, %rdx
callq 0x7150
addq $0x10, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ShowMetricsWindow(bool*)::Funcs::NodeWindow(ImGuiWindow*, char const*)
static void NodeWindow(ImGuiWindow* window, const char* label)
            {
                if (!ImGui::TreeNode(window, "%s '%s', %d @ 0x%p", label, window->Name, window->Active || window->WasActive, window))
                    return;
                NodeDrawList(window->DrawList, "DrawList");
                if (window->RootWindow != window) NodeWindow(window->RootWindow, "RootWindow");
                if (window->DC.ChildWindows.Size > 0) NodeWindows(window->DC.ChildWindows, "ChildWindows");
                ImGui::BulletText("Storage: %d bytes", window->StateStorage.Data.Size * (int)sizeof(ImGuiStorage::Pair));
                ImGui::TreePop();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x70(%rcx)
movb %al, -0x11(%rbp)
jne 0x2c904
movq -0x8(%rbp), %rax
movb 0x71(%rax), %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
movq -0x8(%rbp), %r9
leaq 0x303b2(%rip), %rsi     # 0x5ccd6
movb $0x0, %al
callq 0x1caf0
testb $0x1, %al
jne 0x2c934
jmp 0x2c9bb
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rdi
leaq 0x2fc69(%rip), %rsi     # 0x5c5af
callq 0x2ab80
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x2c973
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
leaq 0x3037b(%rip), %rsi     # 0x5cce9
callq 0x2c8c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x100(%rax)
jle 0x2c99b
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
addq $0x58, %rdi
leaq 0x3035e(%rip), %rsi     # 0x5ccf4
callq 0x2ab00
movq -0x8(%rbp), %rax
movl 0x258(%rax), %esi
shll $0x4, %esi
leaq 0x30352(%rip), %rdi     # 0x5cd01
movb $0x0, %al
callq 0x1c760
callq 0x2a440
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.h
// Function: ImVector<char>::reserve(int)
inline void                 reserve(int new_capacity)
    {
        if (new_capacity <= Capacity) return;
        T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(value_type));
        memcpy(new_data, Data, (size_t)Size * sizeof(value_type));
        ImGui::MemFree(Data);
        Data = new_data;
        Capacity = new_capacity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jg 0x2d961
jmp 0x2d9ac
movslq -0xc(%rbp), %rdi
shlq $0x0, %rdi
callq 0x93d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
movslq (%rax), %rdx
shlq $0x0, %rdx
callq 0x7080
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa760
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_internal.h
// Function: ImRect::GetClosestPoint(ImVec2, bool) const
ImVec2          GetClosestPoint(ImVec2 p, bool on_edge) const
    {
        if (!on_edge && Contains(p))
            return p;
        if (p.x > Max.x) p.x = Max.x;
        else if (p.x < Min.x) p.x = Min.x;
        if (p.y > Max.y) p.y = Max.y;
        else if (p.y < Min.y) p.y = Min.y;
        return p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movlpd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2eda7
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2ec20
testb $0x1, %al
jne 0x2ed9a
jmp 0x2eda7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ee31
movq -0x28(%rbp), %rax
movss -0x10(%rbp), %xmm0
ucomiss 0x8(%rax), %xmm0
jbe 0x2edc6
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0x2ede7
movq -0x28(%rbp), %rax
movss -0x10(%rbp), %xmm1
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2ede5
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0x2ede7
movq -0x28(%rbp), %rax
movss -0xc(%rbp), %xmm0
ucomiss 0xc(%rax), %xmm0
jbe 0x2ee06
movq -0x28(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x2ee29
movq -0x28(%rbp), %rax
movss -0xc(%rbp), %xmm1
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2ee27
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x2ee29
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.h
// Function: ImGuiListClipper::Begin(int, float)
void Begin(int count, float height)        // items_height: generally pass GetTextLineHeightWithSpacing() or GetItemsLineHeightWithSpacing()
    {
        IM_ASSERT(ItemsCount == -1);
        ItemsCount = count;
        ItemsHeight = height;
        ImGui::CalcListClipping(ItemsCount, ItemsHeight, &DisplayStart, &DisplayEnd); // calculate how many to clip/display
        ImGui::SetCursorPosY(ImGui::GetCursorPosY() + DisplayStart * ItemsHeight);    // advance cursor
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, 0x4(%rax)
jne 0x31694
jmp 0x316b3
leaq 0x2b535(%rip), %rdi     # 0x5cbd0
leaq 0x2b035(%rip), %rsi     # 0x5c6d7
movl $0x3e6, %edx            # imm = 0x3E6
leaq 0x2b533(%rip), %rcx     # 0x5cbe1
callq 0x7160
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, 0x4(%rdx)
movss -0x10(%rbp), %xmm0
movss %xmm0, (%rdx)
movl 0x4(%rdx), %edi
movss (%rdx), %xmm0
movq %rdx, %rsi
addq $0x8, %rsi
addq $0xc, %rdx
callq 0x11210
callq 0x19bc0
movq -0x18(%rbp), %rax
movaps %xmm0, %xmm1
cvtsi2ssl 0x8(%rax), %xmm0
movss (%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x19d00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ImGui::ShowUserGuide()
void ImGui::ShowUserGuide()
{
    ImGui::BulletText("Double-click on title bar to collapse window.");
    ImGui::BulletText("Click and drag on lower right corner to resize window.");
    ImGui::BulletText("Click and drag on any empty space to move window.");
    ImGui::BulletText("Mouse Wheel to scroll.");
    if (ImGui::GetIO().FontAllowUserScaling)
        ImGui::BulletText("CTRL+Mouse Wheel to zoom window contents.");
    ImGui::BulletText("TAB/SHIFT+TAB to cycle through keyboard editable fields.");
    ImGui::BulletText("CTRL+Click on a slider or drag box to input text.");
    ImGui::BulletText(
        "While editing text:\n"
        "- Hold SHIFT or use mouse to select text\n"
        "- CTRL+Left/Right to word jump\n"
        "- CTRL+A or double-click to select all\n"
        "- CTRL+X,CTRL+C,CTRL+V clipboard\n"
        "- CTRL+Z,CTRL+Y undo/redo\n"
        "- ESCAPE to revert\n"
        "- You can apply arithmetic operators +,*,/ on numerical values.\n"
        "  Use +- to subtract.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2b239(%rip), %rdi     # 0x5d614
movb $0x0, %al
callq 0x1c760
leaq 0x2b259(%rip), %rdi     # 0x5d642
movb $0x0, %al
callq 0x1c760
leaq 0x2b282(%rip), %rdi     # 0x5d679
movb $0x0, %al
callq 0x1c760
leaq 0x2b2a6(%rip), %rdi     # 0x5d6ab
movb $0x0, %al
callq 0x1c760
callq 0xca90
testb $0x1, 0x94(%rax)
je 0x32428
leaq 0x2b2a1(%rip), %rdi     # 0x5d6c2
movb $0x0, %al
callq 0x1c760
leaq 0x2d13a(%rip), %rdi     # 0x5f569
movb $0x0, %al
callq 0x1c760
leaq 0x2b2af(%rip), %rdi     # 0x5d6ec
movb $0x0, %al
callq 0x1c760
leaq 0x2b2d3(%rip), %rdi     # 0x5d71e
movb $0x0, %al
callq 0x1c760
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ShowExampleAppLog(bool*)
static void ShowExampleAppLog(bool* opened)
{
    static ExampleAppLog log;

    // Demo fill
    static float last_time = -1.0f;
    float time = ImGui::GetTime();
    if (time - last_time >= 0.3f)
    {
        const char* random_words[] = { "system", "info", "warning", "error", "fatal", "notice", "log" };
        log.AddLog("[%s] Hello, time is %.1f, rand() %d\n", random_words[rand() % IM_ARRAYSIZE(random_words)], time, (int)rand());
        last_time = time;
    }

    log.Draw("Example: Log", opened);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x4b1f5(%rip)     # 0x83be8
jne 0x38a3a
leaq 0x4b1ec(%rip), %rdi     # 0x83be8
callq 0x72e0
cmpl $0x0, %eax
je 0x38a3a
leaq 0x4b09b(%rip), %rdi     # 0x83aa8
callq 0x3c410
jmp 0x38a14
leaq 0x3a85(%rip), %rdi      # 0x3c4a0
leaq 0x4b086(%rip), %rsi     # 0x83aa8
leaq 0x40a8f(%rip), %rdx     # 0x794b8
callq 0x76b0
leaq 0x4b1b3(%rip), %rdi     # 0x83be8
callq 0x7460
callq 0xcb10
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
subss 0x44d7b(%rip), %xmm0    # 0x7d7cc
movss 0x225cf(%rip), %xmm1    # 0x5b028
ucomiss %xmm1, %xmm0
jb 0x38aec
leaq -0x50(%rbp), %rdi
leaq 0x3e2d3(%rip), %rsi     # 0x76d40
movl $0x38, %edx
callq 0x7080
callq 0x7760
movl $0x7, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq -0x50(%rbp,%rax,8), %rax
movq %rax, -0x60(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x7760
movq -0x60(%rbp), %rdx
movsd -0x58(%rbp), %xmm0
movl %eax, %ecx
leaq 0x4aff3(%rip), %rdi     # 0x83aa8
leaq 0x27815(%rip), %rsi     # 0x602d1
movb $0x1, %al
callq 0x3c4e0
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x44cfc(%rip)    # 0x7d7cc
jmp 0x38aec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x4b103(%rip), %rdi     # 0x83be8
callq 0x7380
jmp 0x38b09
movq -0x8(%rbp), %rdx
leaq 0x4afb1(%rip), %rdi     # 0x83aa8
leaq 0x277f8(%rip), %rsi     # 0x602f6
callq 0x3c600
addq $0x60, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x74f0
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ShowExampleAppAutoResize(bool*)
static void ShowExampleAppAutoResize(bool* opened)
{
    if (!ImGui::Begin("Example: Auto-resizing window", opened, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::End();
        return;
    }

    static int lines = 10;
    ImGui::Text("Window will resize every-frame to the size of its content.\nNote that you probably don't want to query the window size to\noutput your content because that would create a feedback loop.");
    ImGui::SliderInt("Number of lines", &lines, 1, 20);
    for (int i = 0; i < lines; i++)
        ImGui::Text("%*sThis is line %d", i*4, "", i); // Pad with space to extend size horizontally
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x26b0a(%rip), %rdi     # 0x5fc51
movl $0x40, %edx
callq 0xe7e0
testb $0x1, %al
jne 0x3915c
callq 0xee30
jmp 0x391ce
leaq 0x26b0c(%rip), %rdi     # 0x5fc6f
movb $0x0, %al
callq 0x1a220
leaq 0x26bb6(%rip), %rdi     # 0x5fd27
leaq 0x44650(%rip), %rsi     # 0x7d7c8
movl $0x1, %edx
movl $0x14, %ecx
leaq 0x25b07(%rip), %r8      # 0x5ec90
callq 0x1b910
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4462a(%rip), %eax     # 0x7d7c8
jge 0x391c9
movl -0xc(%rbp), %esi
shll $0x2, %esi
movl -0xc(%rbp), %ecx
leaq 0x26b87(%rip), %rdi     # 0x5fd37
leaq 0x26097(%rip), %rdx     # 0x5f24e
movb $0x0, %al
callq 0x1a220
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39195
callq 0xee30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ShowExampleAppFixedOverlay(bool*)
static void ShowExampleAppFixedOverlay(bool* opened)
{
    ImGui::SetNextWindowPos(ImVec2(10,10));
    if (!ImGui::Begin("Example: Fixed Overlay", opened, ImVec2(0,0), 0.3f, ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoSavedSettings))
    {
        ImGui::End();
        return;
    }
    ImGui::Text("Simple overlay\non the top-left side of the screen.");
    ImGui::Separator();
    ImGui::Text("Mouse Position: (%.1f,%.1f)", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y);
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movss 0x21e68(%rip), %xmm1    # 0x5b060
movaps %xmm1, %xmm0
callq 0x2d280
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x19450
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x20(%rbp), %rsi
leaq 0x26b1d(%rip), %rdi     # 0x5fd4a
leaq -0x18(%rbp), %rdx
movss 0x21def(%rip), %xmm0    # 0x5b028
movl $0x107, %ecx            # imm = 0x107
callq 0x12020
xorb $-0x1, %al
testb $0x1, %al
jne 0x3924b
jmp 0x39252
callq 0xee30
jmp 0x392a4
leaq 0x26b08(%rip), %rdi     # 0x5fd61
movb $0x0, %al
callq 0x1a220
callq 0x29c00
callq 0xca90
movss 0xe8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0xca90
movsd -0x28(%rbp), %xmm0
movss 0xec(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x26afc(%rip), %rdi     # 0x5fd94
movb $0x2, %al
callq 0x1a220
callq 0xee30
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ShowExampleAppManipulatingWindowTitle(bool*)
static void ShowExampleAppManipulatingWindowTitle(bool* opened)
{
    (void)opened;

    // By default, Windows are uniquely identified by their title.
    // You can use the "##" and "###" markers to manipulate the display/ID. Read FAQ at the top of this file!

    // Using "##" to display same title but have unique identifier.
    ImGui::SetNextWindowPos(ImVec2(100,100), ImGuiSetCond_FirstUseEver);
    ImGui::Begin("Same title as another window##1");
    ImGui::Text("This is window 1.\nMy title is the same as window 2, but my identifier is unique.");
    ImGui::End();

    ImGui::SetNextWindowPos(ImVec2(100,200), ImGuiSetCond_FirstUseEver);
    ImGui::Begin("Same title as another window##2");
    ImGui::Text("This is window 2.\nMy title is the same as window 1, but my identifier is unique.");
    ImGui::End();

    // Using "###" to display a changing title but keep a static identifier "AnimatedTitle"
    char buf[128];
    sprintf(buf, "Animated title %c %d###AnimatedTitle", "|/-\\"[(int)(ImGui::GetTime()/0.25f)&3], rand());
    ImGui::SetNextWindowPos(ImVec2(100,300), ImGuiSetCond_FirstUseEver);
    ImGui::Begin(buf);
    ImGui::Text("This window has a changing title.");
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movss 0x21e5d(%rip), %xmm1    # 0x5b128
movaps %xmm1, %xmm0
callq 0x2d280
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x19450
leaq 0x26ac8(%rip), %rdi     # 0x5fdb0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe7e0
leaq 0x26ad6(%rip), %rdi     # 0x5fdd0
movb $0x0, %al
callq 0x1a220
callq 0xee30
leaq -0x18(%rbp), %rdi
movss 0x21e16(%rip), %xmm0    # 0x5b128
movss 0x242ca(%rip), %xmm1    # 0x5d5e4
callq 0x2d280
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x19450
leaq 0x26aed(%rip), %rdi     # 0x5fe21
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe7e0
leaq 0x26afb(%rip), %rdi     # 0x5fe41
movb $0x0, %al
callq 0x1a220
callq 0xee30
leaq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0xcb10
movss 0x21d1b(%rip), %xmm1    # 0x5b088
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x26b35(%rip), %rax     # 0x5feb7
movsbl (%rax,%rcx), %eax
movl %eax, -0xac(%rbp)
callq 0x7760
movq -0xb8(%rbp), %rdi
movl -0xac(%rbp), %edx
movl %eax, %ecx
leaq 0x26aeb(%rip), %rsi     # 0x5fe92
movb $0x0, %al
callq 0x77b0
leaq -0xa8(%rbp), %rdi
movss 0x21d6b(%rip), %xmm0    # 0x5b128
movss 0x241df(%rip), %xmm1    # 0x5d5a4
callq 0x2d280
leaq -0xa8(%rbp), %rdi
movl $0x4, %esi
callq 0x19450
leaq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe7e0
leaq 0x26ac8(%rip), %rdi     # 0x5febc
movb $0x0, %al
callq 0x1a220
callq 0xee30
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ExampleAppConsole::ExampleAppConsole()
ExampleAppConsole()
    {
        ClearLog();
        HistoryPos = -1;
        Commands.push_back("HELP");
        Commands.push_back("HISTORY");
        Commands.push_back("CLEAR");
        Commands.push_back("CLASSIFY");  // "classify" is here to provide an example of "C"+[tab] completing to "CL" and displaying matches.
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq %rdi, -0x50(%rbp)
callq 0x3b360
movq -0x48(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq %rdi, -0x40(%rbp)
callq 0x3b360
jmp 0x3ac0a
movq -0x48(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, -0x58(%rbp)
callq 0x3b390
jmp 0x3ac20
movq -0x48(%rbp), %rdi
callq 0x3b3c0
jmp 0x3ac2b
movq -0x48(%rbp), %rdi
movl $0xffffffff, 0x128(%rdi) # imm = 0xFFFFFFFF
addq $0x130, %rdi            # imm = 0x130
leaq 0x2536e(%rip), %rax     # 0x5ffb5
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x3b440
jmp 0x3ac56
movq -0x48(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq 0x25352(%rip), %rax     # 0x5ffba
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x3b440
jmp 0x3ac77
movq -0x48(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq 0x25339(%rip), %rax     # 0x5ffc2
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3b440
jmp 0x3ac98
movq -0x48(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq 0x2531e(%rip), %rax     # 0x5ffc8
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3b440
jmp 0x3acb9
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x3acf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x3acf0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3b4a0
movq -0x40(%rbp), %rdi
callq 0x3b4e0
movq -0x50(%rbp), %rdi
callq 0x3b4e0
movq -0x10(%rbp), %rdi
callq 0x74f0
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ExampleAppConsole::ClearLog()
void    ClearLog()
    {
        for (int i = 0; i < Items.Size; i++)
            free(Items[i]);
        Items.clear();
        ScrollToBottom = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x100(%rcx), %eax
jge 0x3b410
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0xc(%rbp), %esi
callq 0x3b520
movq (%rax), %rdi
callq 0x7950
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b3db
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x3b580
movq -0x18(%rbp), %rax
movb $0x1, 0x110(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::Clear()
void ImDrawList::Clear()
{
    CmdBuffer.resize(0);
    IdxBuffer.resize(0);
    VtxBuffer.resize(0);
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.resize(0);
    _TextureIdStack.resize(0);
    _Path.resize(0);
    _ChannelsCurrent = 0;
    _ChannelsCount = 1;
    // NB: Do not clear channels so our allocations are re-used after the first frame.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0x4bea0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x2ff70
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4bef0
movq -0x10(%rbp), %rdi
movl $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
addq $0x50, %rdi
xorl %esi, %esi
callq 0x4bf40
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
callq 0x4bf90
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
xorl %esi, %esi
callq 0x31380
movq -0x10(%rbp), %rax
movl $0x0, 0x80(%rax)
movl $0x1, 0x84(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::ClearFreeMemory()
void ImDrawList::ClearFreeMemory()
{
    CmdBuffer.clear();
    IdxBuffer.clear();
    VtxBuffer.clear();
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.clear();
    _TextureIdStack.clear();
    _Path.clear();
    _ChannelsCurrent = 0;
    _ChannelsCount = 1;
    for (int i = 0; i < _Channels.Size; i++)
    {
        if (i == 0) memset(&_Channels[0], 0, sizeof(_Channels[0]));  // channel 0 is a copy of CmdBuffer/IdxBuffer, don't destruct again
        _Channels[i].CmdBuffer.clear();
        _Channels[i].IdxBuffer.clear();
    }
    _Channels.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4bfe0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x2e7a0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x4c030
movq -0x18(%rbp), %rdi
movl $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
addq $0x50, %rdi
callq 0x4c080
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x4c0d0
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x3aab0
movq -0x18(%rbp), %rax
movl $0x0, 0x80(%rax)
movl $0x1, 0x84(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x88(%rcx), %eax
jge 0x3cd7b
cmpl $0x0, -0xc(%rbp)
jne 0x3cd36
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
callq 0x4c120
movq %rax, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7240
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
movl -0xc(%rbp), %esi
callq 0x4c120
movq %rax, %rdi
callq 0x4bfe0
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
movl -0xc(%rbp), %esi
callq 0x4c120
movq %rax, %rdi
addq $0x10, %rdi
callq 0x2e7a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cd00
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x4c180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddDrawCmd()
void ImDrawList::AddDrawCmd()
{
    ImDrawCmd draw_cmd;
    draw_cmd.ClipRect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect;
    draw_cmd.TextureId = _TextureIdStack.Size ? _TextureIdStack.back() : NULL;

    IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
    CmdBuffer.push_back(draw_cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4c1d0
movq -0x40(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x3cdda
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x314a0
movq %rax, -0x48(%rbp)
jmp 0x3cde7
leaq 0x46f5f(%rip), %rax     # 0x83d40
movq %rax, -0x48(%rbp)
jmp 0x3cde7
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, -0x34(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x2c(%rbp)
cmpl $0x0, 0x60(%rax)
je 0x3ce1a
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x4c250
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x3ce22
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x3ce22
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x51(%rbp)
jb 0x3ce51
movss -0x30(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x3ce5a
jmp 0x3ce5c
jmp 0x3ce7b
leaq 0x2763a(%rip), %rdi     # 0x6449d
leaq 0x2768c(%rip), %rsi     # 0x644f6
movl $0x8f, %edx
leaq 0x27697(%rip), %rcx     # 0x6450d
callq 0x7160
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4c2b0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*)
void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    if (!current_cmd || current_cmd->ElemCount != 0 || current_cmd->UserCallback != NULL)
    {
        AddDrawCmd();
        current_cmd = &CmdBuffer.back();
    }
    current_cmd->UserCallback = callback;
    current_cmd->UserCallbackData = callback_data;

    // Force a new command after us (we function this way so that the most common calls AddLine, AddRect, etc. always have a command to add to without doing any check).
    AddDrawCmd();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, (%rax)
je 0x3cec0
movq -0x28(%rbp), %rdi
callq 0x31000
movq %rax, -0x30(%rbp)
jmp 0x3cec8
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3cec8
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ceeb
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3ceeb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3cf01
movq -0x28(%rbp), %rdi
callq 0x3cda0
movq -0x28(%rbp), %rdi
callq 0x31000
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x3cda0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::UpdateClipRect()
void ImDrawList::UpdateClipRect()
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    if (!current_cmd || (current_cmd->ElemCount != 0) || current_cmd->UserCallback != NULL)
    {
        AddDrawCmd();
    }
    else
    {
        ImVec4 current_clip_rect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect;
        if (CmdBuffer.Size >= 2 && ImLengthSqr(CmdBuffer.Data[CmdBuffer.Size-2].ClipRect - current_clip_rect) < 0.00001f)
            CmdBuffer.pop_back();
        else
            current_cmd->ClipRect = current_clip_rect;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, (%rax)
je 0x3cf58
movq -0x38(%rbp), %rdi
callq 0x31000
movq %rax, -0x40(%rbp)
jmp 0x3cf60
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x3cf60
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3cf83
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3cf83
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3cf91
movq -0x38(%rbp), %rdi
callq 0x3cda0
jmp 0x3d053
movq -0x38(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x3cfae
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
callq 0x314a0
movq %rax, -0x48(%rbp)
jmp 0x3cfbb
leaq 0x46d8b(%rip), %rax     # 0x83d40
movq %rax, -0x48(%rbp)
jmp 0x3cfbb
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rdx
movq %rdx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x49(%rbp)
jl 0x3d029
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
addl $-0x2, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x4(%rax,%rcx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d0d0
movlpd %xmm0, -0x30(%rbp)
movlpd %xmm1, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d060
movaps %xmm0, %xmm1
movss 0x1e084(%rip), %xmm0    # 0x5b0a4
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3d032
jmp 0x3d03d
movq -0x38(%rbp), %rdi
callq 0x31060
jmp 0x3d051
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xc(%rax)
jmp 0x3d053
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::UpdateTextureID()
void ImDrawList::UpdateTextureID()
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    const ImTextureID texture_id = _TextureIdStack.Size ? _TextureIdStack.back() : NULL;
    if (!current_cmd || (current_cmd->ElemCount != 0 && current_cmd->TextureId != texture_id) || current_cmd->UserCallback != NULL)
        AddDrawCmd();
    else
        current_cmd->TextureId = texture_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
je 0x3d238
movq -0x20(%rbp), %rdi
callq 0x31000
movq %rax, -0x28(%rbp)
jmp 0x3d240
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3d240
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x0, 0x60(%rax)
je 0x3d268
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0x4c250
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3d270
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3d270
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3d2a1
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3d296
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3d2a1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3d2ac
movq -0x20(%rbp), %rdi
callq 0x3cda0
jmp 0x3d2b8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::ChannelsSetCurrent(int)
void ImDrawList::ChannelsSetCurrent(int idx)
{
    if (_ChannelsCurrent == idx) return;
    memcpy(&_Channels.Data[_ChannelsCurrent].CmdBuffer, &CmdBuffer, sizeof(CmdBuffer)); // copy 12 bytes, four times
    memcpy(&_Channels.Data[_ChannelsCurrent].IdxBuffer, &IdxBuffer, sizeof(IdxBuffer));
    _ChannelsCurrent = idx;
    memcpy(&CmdBuffer, &_Channels.Data[_ChannelsCurrent].CmdBuffer, sizeof(CmdBuffer));
    memcpy(&IdxBuffer, &_Channels.Data[_ChannelsCurrent].IdxBuffer, sizeof(IdxBuffer));
    _IdxWritePtr = IdxBuffer.Data + IdxBuffer.Size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x80(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x3d773
jmp 0x3d822
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
movslq 0x80(%rax), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x90(%rax), %rcx
movslq 0x80(%rax), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%rcx)
movl -0xc(%rbp), %ecx
movl %ecx, 0x80(%rax)
movq 0x90(%rax), %rcx
movslq 0x80(%rax), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x90(%rax), %rcx
movslq 0x80(%rax), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rcx
movslq 0x10(%rax), %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x48(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PrimReserve(int, int)
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
{
    ImDrawCmd& draw_cmd = CmdBuffer.Data[CmdBuffer.Size-1];
    draw_cmd.ElemCount += idx_count;

    int vtx_buffer_size = VtxBuffer.Size;
    VtxBuffer.resize(vtx_buffer_size + vtx_count);
    _VtxWritePtr = VtxBuffer.Data + vtx_buffer_size;

    int idx_buffer_size = IdxBuffer.Size;
    IdxBuffer.resize(idx_buffer_size + idx_count);
    _IdxWritePtr = IdxBuffer.Data + idx_buffer_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x20(%rdi), %eax
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movl -0x1c(%rbp), %esi
addl -0x10(%rbp), %esi
callq 0x4bef0
movq -0x28(%rbp), %rdi
movq 0x28(%rdi), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rdi)
movl 0x10(%rdi), %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
movl -0x20(%rbp), %esi
addl -0xc(%rbp), %esi
callq 0x2ff70
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x20(%rbp), %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRect(ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
{
    const ImVec2 uv = GImGui->FontTexUvWhitePixel;
    const ImVec2 b(c.x, a.y);
    const ImVec2 d(a.x, c.y);
    _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2);
    _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x3bbca(%rip), %rax     # 0x794c0
movq (%rax), %rax
movq 0x1720(%rax), %rax
movq %rax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x2c(%rbp), %rdi
callq 0x2d280
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x34(%rbp), %rdi
callq 0x2d280
movq -0x40(%rbp), %rax
movl 0x38(%rax), %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, (%rcx)
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, 0x2(%rcx)
movl 0x38(%rax), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, 0x4(%rcx)
movl 0x38(%rax), %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, 0x6(%rcx)
movl 0x38(%rax), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, 0x8(%rcx)
movl 0x38(%rax), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x48(%rax), %rcx
movw %dx, 0xa(%rcx)
movq -0x10(%rbp), %rdx
movq 0x40(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq 0x40(%rax), %rcx
movq -0x24(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x1c(%rbp), %edx
movq 0x40(%rax), %rcx
movl %edx, 0x10(%rcx)
movq 0x40(%rax), %rcx
movq -0x2c(%rbp), %rdx
movq %rdx, 0x14(%rcx)
movq 0x40(%rax), %rcx
movq -0x24(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x1c(%rbp), %edx
movq 0x40(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x18(%rbp), %rdx
movq 0x40(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x28(%rcx)
movq 0x40(%rax), %rcx
movq -0x24(%rbp), %rdx
movq %rdx, 0x30(%rcx)
movl -0x1c(%rbp), %edx
movq 0x40(%rax), %rcx
movl %edx, 0x38(%rcx)
movq 0x40(%rax), %rcx
movq -0x34(%rbp), %rdx
movq %rdx, 0x3c(%rcx)
movq 0x40(%rax), %rcx
movq -0x24(%rbp), %rdx
movq %rdx, 0x44(%rcx)
movl -0x1c(%rbp), %edx
movq 0x40(%rax), %rcx
movl %edx, 0x4c(%rcx)
movq 0x40(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x40(%rax)
movl 0x38(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x38(%rax)
movq 0x48(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PathArcTo(ImVec2 const&, float, float, float, int)
void ImDrawList::PathArcTo(const ImVec2& centre, float radius, float amin, float amax, int num_segments)
{
    if (radius == 0.0f)
        _Path.push_back(centre);
    _Path.reserve(_Path.Size + (num_segments + 1));
    for (int i = 0; i <= num_segments; i++)
    {
        const float a = amin + ((float)i / (float)num_segments) * (amax - amin);
        _Path.push_back(ImVec2(centre.x + cosf(a) * radius, centre.y + sinf(a) * radius));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3f9da
jp 0x3f9da
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
callq 0x31200
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x70, %rdi
movl 0x70(%rax), %esi
movl -0x20(%rbp), %eax
addl $0x1, %eax
addl %eax, %esi
callq 0x31260
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x3fac2
movq -0x38(%rbp), %rax
movss -0x18(%rbp), %xmm1
cvtsi2ssl -0x24(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm2
divss %xmm2, %xmm0
movss -0x1c(%rbp), %xmm2
subss -0x18(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
addq $0x70, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x28(%rbp), %xmm0
callq 0x7510
movss -0x4c(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x28(%rbp), %xmm0
callq 0x7050
movss -0x48(%rbp), %xmm2
movaps %xmm0, %xmm1
movss -0x44(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x30(%rbp), %rdi
callq 0x2d280
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31200
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3f9fc
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddLine(ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness)
{
    if ((col >> 24) == 0)
        return;
    PathLineTo(a + ImVec2(0.5f,0.5f));
    PathLineTo(b + ImVec2(0.5f,0.5f));
    PathStroke(col, false, thickness);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x404f4
jmp 0x40587
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movss 0x1ab18(%rip), %xmm1    # 0x5b024
movss %xmm1, -0x5c(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3f120
movq -0x48(%rbp), %rdi
movlpd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2eab0
movss -0x5c(%rbp), %xmm1
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3f120
movq -0x48(%rbp), %rdi
movlpd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2eab0
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %esi
movss -0x20(%rbp), %xmm0
xorl %edx, %edx
callq 0x2eae0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRect(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    PathRect(a + ImVec2(0.5f,0.5f), b + ImVec2(0.5f,0.5f), rounding, rounding_corners);
    PathStroke(col, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x405cb
jmp 0x40663
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x34(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movss 0x1aa41(%rip), %xmm1    # 0x5b024
movss %xmm1, -0x64(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3f120
movss -0x64(%rbp), %xmm1
movlpd %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x44(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3f120
movq -0x50(%rbp), %rdi
movlpd %xmm0, -0x3c(%rbp)
movss -0x20(%rbp), %xmm0
movl -0x24(%rbp), %ecx
leaq -0x2c(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x40090
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
movss 0x1a9ba(%rip), %xmm0    # 0x5b018
callq 0x2eae0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    if (rounding > 0.0f)
    {
        PathRect(a, b, rounding, rounding_corners);
        PathFill(col);
    }
    else
    {
        PrimReserve(6, 4);
        PrimRect(a, b, col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x406a5
jmp 0x40700
movss -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x406d9
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movss -0x20(%rbp), %xmm0
movl -0x24(%rbp), %ecx
callq 0x40090
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2f3f0
jmp 0x40700
movq -0x30(%rbp), %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x3d830
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x3d8d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilledMultiColor(ImVec2 const&, ImVec2 const&, unsigned int, unsigned int, unsigned int, unsigned int)
void ImDrawList::AddRectFilledMultiColor(const ImVec2& a, const ImVec2& c, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
{
    if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) >> 24) == 0)
        return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
orl -0x20(%rbp), %eax
orl -0x24(%rbp), %eax
orl 0x10(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x40753
jmp 0x40865
movq -0x48(%rbp), %rdi
leaq 0x38d62(%rip), %rax     # 0x794c0
movq (%rax), %rax
movq 0x1720(%rax), %rax
movq %rax, -0x2c(%rbp)
movl $0x6, %esi
movl $0x4, %edx
callq 0x3d830
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
addl $0x2, %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
addl $0x2, %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movl 0x38(%rdi), %eax
addl $0x3, %eax
movzwl %ax, %esi
callq 0x4c590
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq -0x2c(%rbp), %rdx
callq 0x4c5c0
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x34(%rbp), %rdi
callq 0x2d280
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %ecx
leaq -0x34(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x4c5c0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
leaq -0x2c(%rbp), %rdx
callq 0x4c5c0
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x3c(%rbp), %rdi
callq 0x2d280
movq -0x48(%rbp), %rdi
movl 0x10(%rbp), %ecx
leaq -0x3c(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x4c5c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddTriangleFilled(ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col)
{
    if ((col >> 24) == 0)
        return;

    PathLineTo(a);
    PathLineTo(b);
    PathLineTo(c);
    PathFill(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x408a1
jmp 0x408d4
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2eab0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2eab0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2eab0
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2f3f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)