LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_INSERTCHARS(ImGuiTextEditState*, int, unsigned short const*, int)
static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
    const int text_len = obj->CurLenW;
    if (new_text_len + text_len + 1 > obj->Text.Size)
        return false;

    const int new_text_len_utf8 = ImTextCountUtf8BytesFromStr(new_text, new_text + new_text_len);
    if (new_text_len_utf8 + obj->CurLenA + 1 > obj->BufSizeA)
        return false;

    ImWchar* text = obj->Text.Data;
    if (pos != text_len)
        memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos) * sizeof(ImWchar));
    memcpy(text + pos, new_text, (size_t)new_text_len * sizeof(ImWchar));

    obj->CurLenW += new_text_len;
    obj->CurLenA += new_text_len_utf8;
    obj->Text[obj->CurLenW] = '\0';

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x3c(%rdi), %r12d
leal (%r12,%rcx), %eax
cmpl 0x8(%rdi), %eax
jge 0x1d502
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
movslq %ecx, %r14
leaq (%rdx,%r14,2), %rsi
movq %rdx, %rdi
callq 0x88c6
movl 0x38(%rbx), %ecx
addl %eax, %ecx
cmpl 0x40(%rbx), %ecx
jge 0x1d502
movl %eax, -0x2c(%rbp)
leaq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rbx), %rax
movslq %r13d, %rcx
subl %r13d, %r12d
je 0x1d4d0
leaq (%rax,%rcx,2), %rsi
leaq (%rsi,%r14,2), %rdi
movslq %r12d, %rdx
addq %rdx, %rdx
movq %rax, %r12
movq %rcx, %r13
callq 0x7130
movq %r13, %rcx
movq %r12, %rax
leaq (%rax,%rcx,2), %rdi
leaq (%r14,%r14), %rdx
movq %r15, %rsi
callq 0x7080
addl 0x3c(%rbx), %r14d
movl %r14d, 0x3c(%rbx)
movl -0x2c(%rbp), %eax
addl %eax, 0x38(%rbx)
movq -0x38(%rbp), %rdi
movl %r14d, %esi
callq 0x1fd90
andw $0x0, (%rax)
movb $0x1, %al
jmp 0x1d504
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_move_to_word_previous(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*)
static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
{
   int c = _state->cursor - 1;
   while( c >= 0 && !is_word_boundary( _str, c ) )
      --c;

   if( c < 0 )
      c = 0;

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rsi), %ebx
movl %ebx, %eax
leal -0x1(%rax), %ebx
testl %eax, %eax
jle 0x1d650
movq %r14, %rdi
movl %ebx, %esi
callq 0x1daaf
testl %eax, %eax
je 0x1d639
xorl %eax, %eax
testl %ebx, %ebx
cmovgl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_move_to_word_next(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*)
static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
{
   const int len = STB_TEXTEDIT_STRINGLEN(_str);
   int c = _state->cursor+1;
   while( c < len && !is_word_boundary( _str, c ) )
      ++c;

   if( c > len )
      c = len;

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x3c(%rdi), %r15d
movl (%rsi), %ebx
movl %ebx, %r12d
leal 0x1(%r12), %ebx
cmpl %r15d, %ebx
jge 0x1d68b
movq %r14, %rdi
movl %ebx, %esi
callq 0x1daaf
testl %eax, %eax
je 0x1d670
cmpl %r15d, %r12d
cmovgel %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_text_createundo(ImGuiStb::StbUndoState*, int, int, int)
static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
{
   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
   if (r == NULL)
      return NULL;

   r->where = pos;
   r->insert_length = (short) insert_len;
   r->delete_length = (short) delete_len;

   if (insert_len == 0) {
      r->char_storage = -1;
      return NULL;
   } else {
      r->char_storage = state->undo_char_point;
      state->undo_char_point = state->undo_char_point + (short) insert_len;
      return &state->undo_char[r->char_storage];
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movw $0x63, 0xc74(%rdi)
movw $0x3e7, 0xc78(%rdi)     # imm = 0x3E7
cmpw $0x63, 0xc72(%rdi)
jne 0x1d96f
movq %rbx, %rdi
callq 0x1da03
cmpl $0x3e7, %r14d           # imm = 0x3E7
jle 0x1d98a
andw $0x0, 0xc72(%rbx)
andw $0x0, 0xc76(%rbx)
jmp 0x1d9f8
movswl 0xc76(%rbx), %eax
leal (%rax,%r14), %ecx
cmpl $0x3e8, %ecx            # imm = 0x3E8
jl 0x1d9a7
movq %rbx, %rdi
callq 0x1da03
jmp 0x1d98a
movswq 0xc72(%rbx), %rcx
leal 0x1(%rcx), %edx
movw %dx, 0xc72(%rbx)
imulq $0xc, %rcx, %rdx
leaq (%rbx,%rdx), %rcx
movl %r12d, (%rbx,%rdx)
movw %r14w, 0x4(%rbx,%rdx)
movw %r15w, 0x6(%rbx,%rdx)
testl %r14d, %r14d
je 0x1d9f3
movslq %eax, %rdx
movw %ax, 0x8(%rcx)
addl %r14d, %eax
movw %ax, 0xc76(%rbx)
leaq (%rbx,%rdx,2), %rax
addq $0x4a4, %rax            # imm = 0x4A4
jmp 0x1d9fa
orw $-0x1, 0x8(%rcx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movzwl 0xc72(%rdi), %eax
testw %ax, %ax
jle 0x1daae
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x8(%rdi)
js 0x1da8d
movswq 0x4(%rbx), %r14
movzwl 0xc76(%rbx), %eax
subl %r14d, %eax
movw %ax, 0xc76(%rbx)
leaq 0x4a4(%rbx), %rdi
leaq (%rbx,%r14,2), %rsi
addq $0x4a4, %rsi            # imm = 0x4A4
movswq %ax, %rdx
addq %rdx, %rdx
callq 0x7130
movzwl 0xc72(%rbx), %eax
xorl %ecx, %ecx
testw %ax, %ax
movl %eax, %edx
cmovlel %ecx, %edx
movzwl %dx, %edx
imulq $0xc, %rdx, %rdx
cmpq %rcx, %rdx
je 0x1da8d
movzwl 0x8(%rbx,%rcx), %esi
testw %si, %si
js 0x1da87
subl %r14d, %esi
movw %si, 0x8(%rbx,%rcx)
addq $0xc, %rcx
jmp 0x1da70
decl %eax
movw %ax, 0xc72(%rbx)
leaq 0xc(%rbx), %rsi
movswq %ax, %rax
imulq $0xc, %rax, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7130
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rcx
cmpb $0x0, 0x70(%rdi)
je 0x1dcc5
pushq $0x1
popq %r8
jmp 0x1dcca
movzbl 0x71(%rbx), %r8d
leaq 0x1a32d(%rip), %rsi     # 0x37ffe
movq %rbx, %rdi
movq %rbx, %r9
xorl %eax, %eax
callq 0x13c99
testb %al, %al
je 0x1dd44
movq 0x270(%rbx), %rdi
callq 0x1d0a8
movq 0x278(%rbx), %rdi
cmpq %rbx, %rdi
je 0x1dd06
leaq 0x1a310(%rip), %rsi     # 0x38011
callq 0x1dcaa
cmpl $0x0, 0x100(%rbx)
jle 0x1dd22
leaq 0x100(%rbx), %rdi
leaq 0x1a2ff(%rip), %rsi     # 0x3801c
callq 0x1d03c
movl 0x258(%rbx), %esi
shll $0x4, %esi
leaq 0x1a2f7(%rip), %rdi     # 0x38029
xorl %eax, %eax
callq 0x139fd
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1cba4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.h
// Function: ImVector<char const*>::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:
cmpl %esi, 0x4(%rdi)
jge 0x26e47
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x82c4
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
callq 0x8d0c
movq %r14, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_internal.h
// Function: ImGuiDrawContext::ImGuiDrawContext()
ImGuiDrawContext()
    {
        CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
        CurrentLineHeight = PrevLineHeight = 0.0f;
        CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
        LogLinePosY = -1.0f;
        TreeDepth = 0;
        LastItemID = 0;
        LastItemRect = ImRect(0.0f,0.0f,0.0f,0.0f);
        LastItemHoveredAndUsable = LastItemHoveredRect = false;
        MenuBarAppending = false;
        MenuBarOffsetX = 0.0f;
        StateStorage = NULL;
        LayoutType = ImGuiLayoutType_Vertical;
        ItemWidth = 0.0f;
        ButtonRepeat = false;
        AllowKeyboardFocus = true;
        TextWrapPos = -1.0f;
        ColorEditMode = ImGuiColorEditMode_RGB;
        memset(StackSizesBackup, 0, sizeof(StackSizesBackup));

        ColumnsStartX = 0.0f;
        ColumnsOffsetX = 0.0f;
        ColumnsCurrent = 0;
        ColumnsCount = 1;
        ColumnsStartPos = ImVec2(0.0f, 0.0f);
        ColumnsCellMinY = ColumnsCellMaxY = 0.0f;
        ColumnsShowBorders = true;
        ColumnsSetID = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x118(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xc0(%rdi)
movl $0xbf800000, %eax       # imm = 0xBF800000
movl %eax, 0x30(%rdi)
andl $0x0, 0x50(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x3f(%rdi)
movups %xmm0, 0x68(%rdi)
movw $0x1, 0x7c(%rdi)
movl %eax, 0x78(%rdi)
andq $0x0, 0xf0(%rdi)
movups %xmm0, 0xe0(%rdi)
movups %xmm0, 0xd0(%rdi)
movl $0x1, 0xf8(%rdi)
movups %xmm0, 0xfc(%rdi)
movb $0x1, 0x10c(%rdi)
andl $0x0, 0x110(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movlps %xmm0, -0x10(%rbp)
testl %esi, %esi
jne 0x1ec2e
leaq -0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x1eb9e
testb %al, %al
jne 0x1ec64
movss -0x10(%rbp), %xmm0
movss 0x8(%rbx), %xmm1
ucomiss %xmm1, %xmm0
ja 0x1ec41
movss (%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1ec46
movss %xmm1, -0x10(%rbp)
movss -0xc(%rbp), %xmm1
movss 0xc(%rbx), %xmm0
ucomiss %xmm0, %xmm1
ja 0x1ec5f
movss 0x4(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1ec64
movss %xmm0, -0xc(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
cmpl $-0x1, 0x4(%rdi)
jne 0x1fe6d
movq %rdi, %rbx
movl %esi, 0x4(%rdi)
movss %xmm0, (%rdi)
leaq 0x8(%rdi), %rax
leaq 0xc(%rdi), %rdx
movl %esi, %edi
movq %rax, %rsi
callq 0xcba5
callq 0x11e72
cvtsi2ssl 0x8(%rbx), %xmm1
mulss (%rbx), %xmm1
addss %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f4e
leaq 0x18084(%rip), %rdi     # 0x37ef8
leaq 0x17c00(%rip), %rsi     # 0x37a7b
leaq 0x18087(%rip), %rcx     # 0x37f09
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18685(%rip), %rdi     # 0x389f8
xorl %eax, %eax
callq 0x139fd
leaq 0x186a5(%rip), %rdi     # 0x38a26
xorl %eax, %eax
callq 0x139fd
leaq 0x186ce(%rip), %rdi     # 0x38a5d
xorl %eax, %eax
callq 0x139fd
leaq 0x186f2(%rip), %rdi     # 0x38a8f
xorl %eax, %eax
callq 0x139fd
callq 0xa0f5
cmpb $0x1, 0x94(%rax)
jne 0x203c0
leaq 0x186ed(%rip), %rdi     # 0x38aa6
xorl %eax, %eax
callq 0x139fd
leaq 0x1a57d(%rip), %rdi     # 0x3a944
xorl %eax, %eax
callq 0x139fd
leaq 0x186fb(%rip), %rdi     # 0x38ad0
xorl %eax, %eax
callq 0x139fd
leaq 0x1871f(%rip), %rdi     # 0x38b02
xorl %eax, %eax
popq %rbp
jmp 0x139fd
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rdi)
movups %xmm0, 0x118(%rdi)
leaq 0x130(%rdi), %r14
movups %xmm0, 0x130(%rdi)
callq 0x26cc0
orl $-0x1, 0x128(%rbx)
leaq 0x14baa(%rip), %rax     # 0x3b390
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x26d0e
leaq 0x14b99(%rip), %rax     # 0x3b395
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x26d0e
leaq 0x14b8b(%rip), %rax     # 0x3b39d
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x26d0e
leaq 0x14b7b(%rip), %rax     # 0x3b3a3
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x26d0e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2684c
jmp 0x2684c
jmp 0x2684c
jmp 0x2684c
movq %rax, %r15
leaq 0x100(%rbx), %r12
addq $0x118, %rbx            # imm = 0x118
movq %r14, %rdi
callq 0x26d60
movq %rbx, %rdi
callq 0x26d7c
movq %r12, %rdi
callq 0x26d7c
movq %r15, %rdi
callq 0x74b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x26cf4
movq %r14, %rdi
movl %r15d, %esi
callq 0x26d98
movq (%rax), %rdi
callq 0x78d0
incl %r15d
jmp 0x26cd7
movq %r14, %rdi
callq 0x26dcc
movb $0x1, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2fed2
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x1f4c4
leaq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x2ff10
andl $0x0, 0x38(%rbx)
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
xorl %esi, %esi
callq 0x2ff4e
leaq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x2ff8c
leaq 0x70(%rbx), %rdi
xorl %esi, %esi
callq 0x1fcac
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2ffca
leaq 0x10(%rbx), %rdi
callq 0x1e996
leaq 0x20(%rbx), %rdi
callq 0x2fff2
andl $0x0, 0x38(%rbx)
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
callq 0x3001a
leaq 0x60(%rbx), %rdi
callq 0x30042
leaq 0x70(%rbx), %rdi
callq 0x26718
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x80(%rbx)
addq $0x88, %rbx
xorl %r14d, %r14d
cmpl (%rbx), %r14d
jge 0x27b9e
testl %r14d, %r14d
jne 0x27b72
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3006a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3006a
movq %rax, %rdi
callq 0x2ffca
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3006a
leaq 0x10(%rax), %rdi
callq 0x1e996
incl %r14d
jmp 0x27b54
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3009e
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x3c(%rbp), %r14
andq $0x0, -0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%r14)
cmpl $0x0, 0x50(%rdi)
je 0x27bda
leaq 0x50(%rbx), %rdi
callq 0x1fd26
jmp 0x27be1
leaq 0x2cbaf(%rip), %rax     # 0x54790
movups (%rax), %xmm0
movups %xmm0, (%r14)
cmpl $0x0, 0x60(%rbx)
je 0x27bfc
leaq 0x60(%rbx), %rdi
callq 0x300c6
movq (%rax), %rax
jmp 0x27bfe
xorl %eax, %eax
movq %rax, -0x28(%rbp)
movss -0x34(%rbp), %xmm0
ucomiss -0x3c(%rbp), %xmm0
jb 0x27c2d
movss -0x30(%rbp), %xmm0
ucomiss -0x38(%rbp), %xmm0
jb 0x27c2d
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x300fe
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17d19(%rip), %rdi     # 0x3f94d
leaq 0x17d6b(%rip), %rsi     # 0x3f9a6
leaq 0x17d7b(%rip), %rcx     # 0x3f9bd
movl $0x8f, %edx
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, (%rdi)
je 0x27c78
movq %r14, %rdi
callq 0x1fac8
cmpl $0x0, (%rax)
jne 0x27c78
cmpq $0x0, 0x20(%rax)
je 0x27c88
movq %r14, %rdi
callq 0x27baa
movq %r14, %rdi
callq 0x1fac8
movq %r15, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27baa
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x27cd9
movq %rbx, %rdi
callq 0x1fac8
cmpl $0x0, (%rax)
jne 0x27cd9
movq %rax, %r14
cmpq $0x0, 0x20(%rax)
jne 0x27cd9
cmpl $0x0, 0x50(%rbx)
je 0x27ce5
leaq 0x50(%rbx), %rdi
callq 0x1fd26
jmp 0x27cec
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x27baa
leaq 0x2caa4(%rip), %rax     # 0x54790
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
movss 0x8(%rax), %xmm2
movss 0xc(%rax), %xmm3
movslq (%rbx), %rax
cmpq $0x2, %rax
jl 0x27d6d
movq 0x8(%rbx), %rcx
imulq $0x30, %rax, %rax
movss -0x5c(%rcx,%rax), %xmm4
movss -0x58(%rcx,%rax), %xmm5
subss %xmm0, %xmm4
subss %xmm1, %xmm5
movss -0x54(%rcx,%rax), %xmm6
subss %xmm2, %xmm6
movss -0x50(%rcx,%rax), %xmm7
subss %xmm7, %xmm7
mulss %xmm5, %xmm5
mulss %xmm4, %xmm4
addss %xmm5, %xmm4
mulss %xmm6, %xmm6
addss %xmm4, %xmm6
mulss %xmm7, %xmm7
addss %xmm6, %xmm7
movss 0xe65c(%rip), %xmm4     # 0x363b8
ucomiss %xmm7, %xmm4
jbe 0x27d6d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1fb04
movss %xmm0, 0x4(%r14)
movss %xmm1, 0x8(%r14)
movss %xmm2, 0xc(%r14)
movss %xmm3, 0x10(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x27e1e
movq %rbx, %rdi
callq 0x1fac8
movq %rax, %r14
jmp 0x27e21
xorl %r14d, %r14d
cmpl $0x0, 0x60(%rbx)
je 0x27e35
leaq 0x60(%rbx), %rdi
callq 0x300c6
movq (%rax), %rax
jmp 0x27e37
xorl %eax, %eax
testq %r14, %r14
je 0x27e4f
cmpl $0x0, (%r14)
je 0x27e48
cmpq %rax, 0x18(%r14)
jne 0x27e4f
cmpq $0x0, 0x20(%r14)
je 0x27e5b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x27baa
movq %rax, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::ChannelsSplit(int)
void ImDrawList::ChannelsSplit(int channels_count)
{
    IM_ASSERT(_ChannelsCurrent == 0 && _ChannelsCount == 1);
    int old_channels_count = _Channels.Size;
    if (old_channels_count < channels_count)
        _Channels.resize(channels_count);
    _ChannelsCount = channels_count;

    // _Channels[] (24 bytes each) hold storage that we'll swap with this->_CmdBuffer/_IdxBuffer
    // The content of _Channels[0] at this point doesn't matter. We clear it to make state tidy in a debugger but we don't strictly need to.
    // When we switch to the next channel, we'll copy _CmdBuffer/_IdxBuffer into _Channels[0] and then _Channels[1] into _CmdBuffer/_IdxBuffer
    memset(&_Channels[0], 0, sizeof(ImDrawChannel));
    for (int i = 1; i < channels_count; i++)
    {
        if (i >= old_channels_count)
        {
            new(&_Channels[i]) ImDrawChannel();
        }
        else
        {
            _Channels[i].CmdBuffer.resize(0);
            _Channels[i].IdxBuffer.resize(0);
        }
        if (_Channels[i].CmdBuffer.Size == 0)
        {
            ImDrawCmd draw_cmd;
            draw_cmd.ClipRect = _ClipRectStack.back();
            draw_cmd.TextureId = _TextureIdStack.back();
            _Channels[i].CmdBuffer.push_back(draw_cmd);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, 0x80(%rdi)
jne 0x2801b
movq %rdi, %r13
cmpl $0x1, 0x84(%rdi)
jne 0x2801b
movl %esi, %ebx
leaq 0x88(%r13), %r15
movl 0x88(%r13), %r12d
cmpl %esi, %r12d
jge 0x27f17
movq %r15, %rdi
movl %ebx, %esi
callq 0x3026e
movl %ebx, 0x84(%r13)
movq %r15, %rdi
xorl %esi, %esi
callq 0x3006a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
leaq -0x64(%rbp), %r14
leaq 0x50(%r13), %rax
movq %rax, -0x30(%rbp)
addq $0x60, %r13
movq %r13, -0x38(%rbp)
pushq $0x1
popq %r13
cmpl %ebx, %r13d
jge 0x2800c
movq %r15, %rdi
movl %r13d, %esi
callq 0x3006a
cmpl %r12d, %r13d
jge 0x27f85
movq %rax, %rdi
xorl %esi, %esi
callq 0x2fed2
movq %r15, %rdi
movl %r13d, %esi
callq 0x3006a
leaq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x1f4c4
jmp 0x27f8f
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %r15, %rdi
movl %r13d, %esi
callq 0x3006a
cmpl $0x0, (%rax)
jne 0x28004
andq $0x0, -0x68(%rbp)
movabsq $-0x39ffffff3a000000, %rax # imm = 0xC6000000C6000000
movq %rax, -0x64(%rbp)
movabsq $0x4600000046000000, %rax # imm = 0x4600000046000000
movq %rax, -0x5c(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%r14)
andq $0x0, 0x24(%r14)
movq -0x30(%rbp), %rdi
callq 0x1fd26
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq -0x38(%rbp), %rdi
callq 0x300c6
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x3006a
movq %rax, %rdi
leaq -0x68(%rbp), %rsi
callq 0x300fe
incl %r13d
jmp 0x27f4a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17a29(%rip), %rdi     # 0x3fa4b
leaq 0x1797d(%rip), %rsi     # 0x3f9a6
leaq 0x17a48(%rip), %rcx     # 0x3fa78
movl $0xe3, %edx
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x30, %rcx, %rcx
addl %esi, -0x30(%rax,%rcx)
addq $0x20, %rdi
movslq 0x20(%rbx), %r15
leal (%rdx,%r15), %esi
callq 0x2ff10
imulq $0x14, %r15, %rax
addq 0x28(%rbx), %rax
movq %rax, 0x40(%rbx)
leaq 0x10(%rbx), %rdi
movslq 0x10(%rbx), %r15
addl %r15d, %r14d
movl %r14d, %esi
callq 0x1f4c4
addq %r15, %r15
addq 0x18(%rbx), %r15
movq %r15, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PathArcToFast(ImVec2 const&, float, int, int)
void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int amin, int amax)
{
    static ImVec2 circle_vtx[12];
    static bool circle_vtx_builds = false;
    const int circle_vtx_count = IM_ARRAYSIZE(circle_vtx);
    if (!circle_vtx_builds)
    {
        for (int i = 0; i < circle_vtx_count; i++)
        {
            const float a = ((float)i / (float)circle_vtx_count) * 2*IM_PI;
            circle_vtx[i].x = cosf(a);
            circle_vtx[i].y = sinf(a);
        }
        circle_vtx_builds = true;
    }

    if (amin > amax) return;
    if (radius == 0.0f)
    {
        _Path.push_back(centre);
    }
    else
    {
        _Path.reserve(_Path.Size + (amax - amin + 1));
        for (int a = amin; a <= amax; a++)
        {
            const ImVec2& c = circle_vtx[a % circle_vtx_count];
            _Path.push_back(ImVec2(centre.x + c.x * radius, centre.y + c.y * radius));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x30(%rbp)
movl %edx, %r15d
movaps %xmm0, %xmm1
movq %rsi, %r14
movq %rdi, %r12
movb 0x31c9c(%rip), %al      # 0x5ad70
testb %al, %al
movss %xmm0, -0x2c(%rbp)
je 0x291ed
cmpb $0x0, 0x31c90(%rip)     # 0x5ad78
jne 0x29144
xorl %ebx, %ebx
leaq 0x31c1d(%rip), %r13     # 0x5ad10
cmpq $0xc, %rbx
je 0x2913d
cvtsi2ss %ebx, %xmm0
divss 0x128cf(%rip), %xmm0    # 0x3b9d4
addss %xmm0, %xmm0
mulss 0x128c7(%rip), %xmm0    # 0x3b9d8
movss %xmm0, -0x34(%rbp)
callq 0x74e0
movss %xmm0, (%r13,%rbx,8)
movss -0x34(%rbp), %xmm0
callq 0x7050
movss -0x2c(%rbp), %xmm1
movss %xmm0, 0x4(%r13,%rbx,8)
incq %rbx
jmp 0x290f3
movb $0x1, 0x31c34(%rip)     # 0x5ad78
movl -0x30(%rbp), %eax
subl %r15d, %eax
jge 0x2915b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x70, %r12
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x29182
jp 0x29182
movq %r12, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fbe6
movl (%r12), %ecx
leal (%rax,%rcx), %esi
incl %esi
movq %r12, %rdi
callq 0x1fc3a
leaq 0x31b76(%rip), %rbx     # 0x5ad10
leaq -0x3c(%rbp), %r13
cmpl -0x30(%rbp), %r15d
movss -0x2c(%rbp), %xmm2
jg 0x2914c
movl %r15d, %eax
cltd
pushq $0xc
popq %rcx
idivl %ecx
movslq %edx, %rax
movss (%rbx,%rax,8), %xmm0
mulss %xmm2, %xmm0
addss (%r14), %xmm0
movss 0x4(%rbx,%rax,8), %xmm1
mulss %xmm2, %xmm1
addss 0x4(%r14), %xmm1
movss %xmm0, -0x3c(%rbp)
movss %xmm1, -0x38(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1fbe6
incl %r15d
jmp 0x2919e
leaq 0x31b7c(%rip), %rdi     # 0x5ad70
callq 0x72a0
movss -0x2c(%rbp), %xmm1
testl %eax, %eax
je 0x290e1
xorps %xmm0, %xmm0
movaps %xmm0, 0x31b50(%rip)    # 0x5ad60
movaps %xmm0, 0x31b39(%rip)    # 0x5ad50
movaps %xmm0, 0x31b22(%rip)    # 0x5ad40
movaps %xmm0, 0x31b0b(%rip)    # 0x5ad30
movaps %xmm0, 0x31af4(%rip)    # 0x5ad20
movaps %xmm0, 0x31add(%rip)    # 0x5ad10
leaq 0x31b36(%rip), %rdi     # 0x5ad70
callq 0x7420
movss -0x2c(%rbp), %xmm1
jmp 0x290e1
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movss %xmm2, -0x2c(%rbp)
movss %xmm1, -0x34(%rbp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm1, %xmm1
movss %xmm0, -0x38(%rbp)
ucomiss %xmm1, %xmm0
jne 0x29288
jp 0x29288
leaq 0x70(%r15), %rdi
movq %r14, %rsi
callq 0x1fbe6
movl 0x70(%r15), %eax
addq $0x70, %r15
leal (%rbx,%rax), %esi
incl %esi
movq %r15, %rdi
callq 0x1fc3a
cvtsi2ss %ebx, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
xorl %r13d, %r13d
leaq -0x4c(%rbp), %r12
cmpl %ebx, %r13d
jg 0x29336
cvtsi2ss %r13d, %xmm0
divss -0x3c(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
addss -0x34(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss (%r14), %xmm1
movss %xmm1, -0x30(%rbp)
callq 0x74e0
mulss -0x38(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss 0x4(%r14), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x44(%rbp), %xmm0
callq 0x7050
mulss -0x38(%rbp), %xmm0
addss -0x40(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss %xmm1, -0x4c(%rbp)
movss %xmm0, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fbe6
incl %r13d
jmp 0x292bc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PathBezierCurveTo(ImVec2 const&, ImVec2 const&, ImVec2 const&, int)
void ImDrawList::PathBezierCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments)
{
    ImVec2 p1 = _Path.back();
    if (num_segments == 0)
    {
        // Auto-tessellated
        PathBezierToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y, GImGui->Style.CurveTessellationTol, 0);
    }
    else
    {
        float t_step = 1.0f / (float)num_segments;
        for (int i_step = 1; i_step <= num_segments; i_step++)
        {
            float t = t_step * i_step;
            float u = 1.0f - t;
            float w1 = u*u*u;
            float w2 = 3*u*u*t;
            float w3 = 3*u*t*t;
            float w4 = t*t*t;
            _Path.push_back(ImVec2(w1*p1.x + w2*p2.x + w3*p3.x + w4*p4.x, w1*p1.y + w2*p2.y + w3*p3.y + w4*p4.y));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x302ac
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
testl %r13d, %r13d
je 0x29487
movq %rbx, -0x48(%rbp)
cvtsi2ss %r13d, %xmm2
movss 0xcffb(%rip), %xmm3     # 0x36390
divss %xmm2, %xmm3
movss %xmm3, -0x2c(%rbp)
movl %r13d, %eax
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
negl %r13d
pushq $0x1
popq %rbx
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
leal (%rbx,%r13), %eax
cmpl $0x1, %eax
je 0x294cd
cvtsi2ss %ebx, %xmm4
mulss -0x2c(%rbp), %xmm4
movss 0xcfb8(%rip), %xmm2     # 0x36390
subss %xmm4, %xmm2
movaps %xmm2, %xmm6
mulss %xmm2, %xmm6
mulss %xmm2, %xmm6
movaps %xmm2, %xmm7
mulss 0xcffe(%rip), %xmm7     # 0x363f0
mulss %xmm7, %xmm2
mulss %xmm4, %xmm2
mulss %xmm4, %xmm7
mulss %xmm4, %xmm7
movaps %xmm4, %xmm3
mulss %xmm4, %xmm3
mulss %xmm4, %xmm3
movss (%r12), %xmm4
mulss %xmm2, %xmm4
movaps %xmm6, %xmm5
mulss %xmm0, %xmm5
addss %xmm4, %xmm5
movss (%r15), %xmm4
mulss %xmm7, %xmm4
addss %xmm5, %xmm4
movss (%r14), %xmm5
mulss %xmm3, %xmm5
addss %xmm4, %xmm5
mulss 0x4(%r12), %xmm2
mulss %xmm1, %xmm6
addss %xmm2, %xmm6
mulss 0x4(%r15), %xmm7
mulss 0x4(%r14), %xmm3
addss %xmm6, %xmm7
addss %xmm7, %xmm3
movss %xmm5, -0x3c(%rbp)
movss %xmm3, -0x38(%rbp)
movq -0x48(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1fbe6
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
incl %ebx
jmp 0x293ba
movss (%r12), %xmm2
movss 0x4(%r12), %xmm3
movss (%r15), %xmm4
movss 0x4(%r15), %xmm5
movss (%r14), %xmm6
movss 0x4(%r14), %xmm7
leaq 0x26fcf(%rip), %rax     # 0x50480
movq (%rax), %rax
movss 0x145c(%rax), %xmm8
movss %xmm8, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x294dc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddLine(ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness)
{
    if ((col >> 24) == 0)
        return;
    PathLineTo(a + ImVec2(0.5f,0.5f));
    PathLineTo(b + ImVec2(0.5f,0.5f));
    PathStroke(col, false, thickness);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x299c8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
movss 0xca83(%rip), %xmm2     # 0x363d0
movss %xmm0, -0x2c(%rbp)
movss (%rsi), %xmm0
addss %xmm2, %xmm0
movss 0x4(%rsi), %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x38(%rbp), %r12
movlps %xmm0, (%r12)
leaq 0x70(%rdi), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1fbe6
movss (%r15), %xmm0
movss 0xca45(%rip), %xmm1     # 0x363d0
addss %xmm1, %xmm0
addss 0x4(%r15), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, (%r12)
leaq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0x1fbe6
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x2c(%rbp), %xmm0
callq 0x1eb26
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRect(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    PathRect(a + ImVec2(0.5f,0.5f), b + ImVec2(0.5f,0.5f), rounding, rounding_corners);
    PathStroke(col, true);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x29a41
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movss 0xc9e6(%rip), %xmm1     # 0x363d0
movss (%rsi), %xmm2
addss %xmm1, %xmm2
movss 0x4(%rsi), %xmm3
addss %xmm1, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
leaq -0x20(%rbp), %rsi
movlps %xmm2, (%rsi)
movss (%rdx), %xmm2
addss %xmm1, %xmm2
addss 0x4(%rdx), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x18(%rbp), %rdx
movlps %xmm2, (%rdx)
movl %r8d, %ecx
callq 0x296e6
pushq $0x1
popq %rdx
movss 0xc961(%rip), %xmm0     # 0x36390
movq %r14, %rdi
movl %ebx, %esi
callq 0x1eb26
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    if (rounding > 0.0f)
    {
        PathRect(a, b, rounding, rounding_corners);
        PathFill(col);
    }
    else
    {
        PrimReserve(6, 4);
        PrimRect(a, b, col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1000000, %ecx        # imm = 0x1000000
jae 0x29a5e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x29a94
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x296e6
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1eed4
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x2820c
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28272
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilledMultiColor(ImVec2 const&, ImVec2 const&, unsigned int, unsigned int, unsigned int, unsigned int)
void ImDrawList::AddRectFilledMultiColor(const ImVec2& a, const ImVec2& c, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
{
    if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) >> 24) == 0)
        return;

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

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

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

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jae 0x29c47
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
cvtsi2ss %ecx, %xmm1
movss 0xc73d(%rip), %xmm2     # 0x3639c
addss %xmm1, %xmm2
mulss 0xc7e9(%rip), %xmm2     # 0x36454
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2924a
pushq $0x1
popq %rdx
movss 0xc70c(%rip), %xmm0     # 0x36390
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1eb26
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircleFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jae 0x29c9b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
cvtsi2ss %ecx, %xmm1
movss 0xc6e9(%rip), %xmm2     # 0x3639c
addss %xmm1, %xmm2
mulss 0xc795(%rip), %xmm2     # 0x36454
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2924a
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1eed4
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierCurve(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments) 
{ 
    if ((col >> 24) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %r9d        # imm = 0x1000000
jae 0x29ce6
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
movl 0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x70, %rdi
movss %xmm0, -0x30(%rbp)
callq 0x1fbe6
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl -0x2c(%rbp), %r8d
callq 0x29346
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x30(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1eb26
nop