LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_DELETECHARS(ImGuiTextEditState*, int, int)
static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
    ImWchar* dst = obj->Text.Data + pos;

    // We maintain our buffer length in both UTF-8 and wchar formats
    obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
    obj->CurLenW -= n;

    // Offset remaining text
    const ImWchar* src = obj->Text.Data + pos + n;
    while (ImWchar c = *src++)
        *dst++ = c;
    *dst = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movslq %esi, %rbx
addq %rbx, %rbx
addq 0x10(%rdi), %rbx
movslq %edx, %r12
leaq (%rbx,%r12,2), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8baa
subl %eax, 0x38(%r14)
subl %r12d, 0x3c(%r14)
movzwl (%r15), %eax
testw %ax, %ax
je 0x23507
leaq 0x2(%rbx), %rcx
movw %ax, (%rbx)
movzwl 0x2(%rbx,%r12,2), %eax
movq %rcx, %rbx
testw %ax, %ax
jne 0x234f0
jmp 0x2350a
movq %rbx, %rcx
movw $0x0, (%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl 0x3c(%rdi), %r15d
leal (%r15,%rcx), %eax
cmpl 0x8(%rdi), %eax
jge 0x235be
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
movslq %ecx, %r13
leaq (%rdx,%r13,2), %rsi
movq %rdx, %rdi
callq 0x8baa
movl 0x38(%rbx), %ecx
addl %eax, %ecx
cmpl 0x40(%rbx), %ecx
jge 0x235be
movl %eax, -0x2c(%rbp)
movq 0x10(%rbx), %rax
movslq %r12d, %rcx
subl %r12d, %r15d
je 0x23587
leaq (%rax,%rcx,2), %rsi
leaq (%rsi,%r13,2), %rdi
movslq %r15d, %rdx
addq %rdx, %rdx
movq %rax, %r15
movq %rcx, %r12
callq 0x7130
movq %r12, %rcx
movq %r15, %rax
leaq (%rax,%rcx,2), %rdi
leaq (,%r13,2), %rdx
movq %r14, %rsi
callq 0x7080
movslq 0x3c(%rbx), %rax
addq %r13, %rax
movl %eax, 0x3c(%rbx)
movl -0x2c(%rbp), %ecx
addl %ecx, 0x38(%rbx)
cmpl %eax, 0x8(%rbx)
jle 0x235cf
movq 0x10(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movb $0x1, %al
jmp 0x235c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b80a(%rip), %rdi     # 0x3ede0
leaq 0x1b4e6(%rip), %rsi     # 0x3eac3
leaq 0x1b805(%rip), %rcx     # 0x3ede9
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x239cf
movq %rbx, %rdi
callq 0x23a78
cmpl $0x3e7, %r14d           # imm = 0x3E7
jle 0x239ed
xorl %eax, %eax
movw %ax, 0xc72(%rbx)
movw %ax, 0xc76(%rbx)
jmp 0x23a6f
movswl 0xc76(%rbx), %eax
movl %eax, %ecx
addl %r14d, %ecx
cmpl $0x3e8, %ecx            # imm = 0x3E8
jl 0x23a1c
movq %rbx, %rdi
callq 0x23a78
movswl 0xc76(%rbx), %eax
leal (%rax,%r14), %ecx
cmpl $0x3e7, %ecx            # imm = 0x3E7
jg 0x23a01
movswq 0xc72(%rbx), %rcx
leal 0x1(%rcx), %edx
movw %dx, 0xc72(%rbx)
leaq (%rcx,%rcx,2), %rcx
leaq (%rbx,%rcx,4), %rcx
movl %r12d, (%rcx)
movw %r14w, 0x4(%rcx)
movw %r15w, 0x6(%rcx)
testl %r14d, %r14d
je 0x23a67
movw %ax, 0x8(%rcx)
leal (%r14,%rax), %ecx
movw %cx, 0xc76(%rbx)
movswq %ax, %rax
leaq (%rbx,%rax,2), %rax
addq $0x4a4, %rax            # imm = 0x4A4
jmp 0x23a6f
movw $0xffff, 0x8(%rcx)      # imm = 0xFFFF
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23b27
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x8(%rdi)
js 0x23b02
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
movswq 0xc72(%rbx), %rax
testq %rax, %rax
jle 0x23b02
movq %rax, %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movzwl 0x8(%rbx,%rdx), %esi
testw %si, %si
js 0x23af9
subl %r14d, %esi
movw %si, 0x8(%rbx,%rdx)
addq $0xc, %rdx
cmpq %rdx, %rcx
jne 0x23ae7
decl %eax
movw %ax, 0xc72(%rbx)
leaq 0xc(%rbx), %rsi
movswq %ax, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7130
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %r8d
cmpb $0x0, 0x70(%rdi)
jne 0x23db0
movzbl 0x71(%rbx), %r8d
leaq 0x1b1da(%rip), %rsi     # 0x3ef91
movq %rbx, %rdi
movq %rbx, %r9
xorl %eax, %eax
callq 0x17ca1
testb %al, %al
je 0x23e2a
movq 0x270(%rbx), %rdi
callq 0x22eaa
movq 0x278(%rbx), %rdi
cmpq %rbx, %rdi
je 0x23dec
leaq 0x1b1bd(%rip), %rsi     # 0x3efa4
callq 0x23d90
cmpl $0x0, 0x100(%rbx)
jle 0x23e08
leaq 0x100(%rbx), %rdi
leaq 0x1b1ac(%rip), %rsi     # 0x3efaf
callq 0x22e3e
movl 0x258(%rbx), %esi
shll $0x4, %esi
leaq 0x1b1a4(%rip), %rdi     # 0x3efbc
xorl %eax, %eax
callq 0x179b7
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x228ce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.h
// Function: ImVector<char>::resize(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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jge 0x242e6
testl %eax, %eax
je 0x2428d
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x24293
movl $0x8, %r12d
cmpl %ebx, %r12d
cmovlel %ebx, %r12d
movslq %r12d, %rdi
movq 0x311dc(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x311b3(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x242d8
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movl %ebx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24b72
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 0xecba
movq 0x3097b(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movss 0xac(%rax), %xmm0
movss 0x1c(%rax), %xmm1
movss 0x50(%rax), %xmm2
subss %xmm1, %xmm0
cvtsi2ssl 0x8(%rbx), %xmm3
addss %xmm2, %xmm0
mulss (%rbx), %xmm3
addss %xmm0, %xmm3
movb $0x1, 0x72(%rax)
subss %xmm2, %xmm1
addss %xmm3, %xmm1
movss %xmm1, 0xac(%rax)
movss 0xc4(%rax), %xmm0
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0xc4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1a312(%rip), %rdi     # 0x3ee8b
leaq 0x19f43(%rip), %rsi     # 0x3eac3
leaq 0x1a315(%rip), %rcx     # 0x3ee9c
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x7140
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ac69(%rip), %rdi     # 0x3f808
xorl %eax, %eax
callq 0x179b7
leaq 0x1ac89(%rip), %rdi     # 0x3f836
xorl %eax, %eax
callq 0x179b7
leaq 0x1acb2(%rip), %rdi     # 0x3f86d
xorl %eax, %eax
callq 0x179b7
leaq 0x1acd6(%rip), %rdi     # 0x3f89f
xorl %eax, %eax
callq 0x179b7
callq 0xb0ca
cmpb $0x1, 0x94(%rax)
jne 0x24bec
leaq 0x1acd1(%rip), %rdi     # 0x3f8b6
xorl %eax, %eax
callq 0x179b7
leaq 0x1cb61(%rip), %rdi     # 0x41754
xorl %eax, %eax
callq 0x179b7
leaq 0x1acdf(%rip), %rdi     # 0x3f8e0
xorl %eax, %eax
callq 0x179b7
leaq 0x1ad03(%rip), %rdi     # 0x3f912
xorl %eax, %eax
popq %rbp
jmp 0x179b7
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x100(%rdi)
jle 0x2bb1b
xorl %r14d, %r14d
movq 0x108(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x78e0
incq %r14
movslq 0x100(%rbx), %rax
cmpq %rax, %r14
jl 0x2bafc
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x2bb3d
xorl %r14d, %r14d
movq %r14, 0x100(%rbx)
callq 0x9019
movq %r14, 0x108(%rbx)
movb $0x1, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jns 0x2c8f5
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq (%rbx), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
callq 0x9019
movq %r14, 0x8(%rbx)
movl $0x0, 0x4(%rbx)
movl $0x0, (%rbx)
cmpl $0x0, 0x14(%rbx)
jns 0x2c932
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x18(%rbx), %rsi
movslq 0x10(%rbx), %rdx
addq %rdx, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x18(%rbx), %rdi
callq 0x9019
movq %r14, 0x18(%rbx)
movl $0x0, 0x14(%rbx)
movl $0x0, 0x10(%rbx)
cmpl $0x0, 0x24(%rbx)
jns 0x2c975
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x28(%rbx), %rsi
movslq 0x20(%rbx), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x28(%rbx), %rdi
callq 0x9019
movq %r14, 0x28(%rbx)
movl $0x0, 0x24(%rbx)
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movl %eax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
cmpl %eax, 0x54(%rbx)
jns 0x2c9bb
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x58(%rbx), %rsi
movslq 0x50(%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x58(%rbx), %rdi
callq 0x9019
movq %r14, 0x58(%rbx)
movl $0x0, 0x54(%rbx)
movl $0x0, 0x50(%rbx)
cmpl $0x0, 0x64(%rbx)
jns 0x2c9fa
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x68(%rbx), %rsi
movslq 0x60(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x68(%rbx), %rdi
callq 0x9019
movq %r14, 0x68(%rbx)
movl $0x0, 0x64(%rbx)
movl $0x0, 0x60(%rbx)
cmpl $0x0, 0x74(%rbx)
jns 0x2ca39
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x80(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2ca7f
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x9019
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca98
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x9019
movq %r14, 0x18(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2cab1
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
callq 0x9019
movq %r14, 0x28(%rbx)
movl $0x0, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x2cad8
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
callq 0x9019
movq %r14, 0x58(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x2caf1
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
callq 0x9019
movq %r14, 0x68(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2cb0a
xorl %r14d, %r14d
movq %r14, 0x70(%rbx)
callq 0x9019
movq %r14, 0x78(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x80(%rbx)
movl 0x88(%rbx), %eax
testl %eax, %eax
jle 0x2cbed
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x90(%rbx), %r13
testq %r15, %r15
je 0x2cb75
movq 0x8(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x2cb5d
movq %r14, (%r13,%r15)
callq 0x9019
movq %r14, 0x8(%r13,%r15)
movl 0x88(%rbx), %eax
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x2cc1e
movq 0x90(%rbx), %r13
addq %r15, %r13
jmp 0x2cbbe
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movl 0x88(%rbx), %eax
testl %eax, %eax
jle 0x2cc1e
movq 0x90(%rbx), %r13
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x2cbb7
movq %r14, (%r13)
callq 0x9019
movq %r14, 0x8(%r13)
movl 0x88(%rbx), %eax
testl %eax, %eax
jle 0x2cc1e
movq 0x90(%rbx), %r13
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0x2cbda
movq %r14, 0x10(%r13)
callq 0x9019
movq %r14, 0x18(%r13)
movl 0x88(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x2cb32
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x2cc0f
xorl %r14d, %r14d
movq %r14, 0x88(%rbx)
callq 0x9019
movq %r14, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x121bb(%rip), %rdi     # 0x3ede0
leaq 0x11e97(%rip), %rsi     # 0x3eac3
leaq 0x1a67b(%rip), %rcx     # 0x472ae
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %eax
testq %rax, %rax
je 0x2cc73
testl %eax, %eax
jle 0x2cdb7
movq 0x58(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x2cc7a
leaq 0x2cb16(%rip), %rax     # 0x59790
movl (%rax), %r15d
movss 0x4(%rax), %xmm1
movss 0x8(%rax), %xmm2
movss 0xc(%rax), %xmm3
movl 0x60(%rbx), %eax
testq %rax, %rax
je 0x2cca7
testl %eax, %eax
jle 0x2cdce
movq 0x68(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %r12
jmp 0x2ccaa
xorl %r12d, %r12d
movd %r15d, %xmm0
ucomiss %xmm0, %xmm2
jb 0x2cd98
ucomiss %xmm1, %xmm3
jb 0x2cd98
movl (%rbx), %eax
cmpl 0x4(%rbx), %eax
jne 0x2cceb
leal 0x1(%rax), %ecx
testl %eax, %eax
movss %xmm1, -0x34(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm3, -0x2c(%rbp)
je 0x2ccf1
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2ccf6
movq 0x8(%rbx), %r14
jmp 0x2cd4a
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r13
movq %r13, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0x8589
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq (%rbx), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
callq 0x9019
movq %r14, 0x8(%rbx)
movl %r13d, 0x4(%rbx)
movl (%rbx), %eax
movss -0x34(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x0, (%r14,%rax)
movl %r15d, 0x4(%r14,%rax)
movss %xmm1, 0x8(%r14,%rax)
movss %xmm2, 0xc(%r14,%rax)
movss %xmm3, 0x10(%r14,%rax)
movq %r12, 0x18(%r14,%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14,%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1999e(%rip), %rdi     # 0x4673d
leaq 0x199f0(%rip), %rsi     # 0x46796
leaq 0x19a00(%rip), %rcx     # 0x467ad
movl $0x8f, %edx
callq 0x7140
leaq 0x19d77(%rip), %rdi     # 0x46b35
leaq 0x11cfe(%rip), %rsi     # 0x3eac3
leaq 0x11f7e(%rip), %rcx     # 0x3ed4a
jmp 0x2cde3
leaq 0x19d60(%rip), %rdi     # 0x46b35
leaq 0x11ce7(%rip), %rsi     # 0x3eac3
leaq 0x1a514(%rip), %rcx     # 0x472f7
movl $0x326, %edx            # imm = 0x326
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %eax
testq %rax, %rax
je 0x2ce2d
testl %eax, %eax
jle 0x2ce6a
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
addq 0x8(%r14), %rcx
movq %rcx, %rax
addq $-0x30, %rax
je 0x2ce2d
cmpl $0x0, (%rax)
jne 0x2ce2d
cmpq $0x0, -0x10(%rcx)
je 0x2ce50
movq %r14, %rdi
callq 0x2cc3e
movslq (%r14), %rax
testq %rax, %rax
jle 0x2ce6a
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x30, %rax
movq %r15, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2cc3e
leaq 0x19cc4(%rip), %rdi     # 0x46b35
leaq 0x11c4b(%rip), %rsi     # 0x3eac3
leaq 0x11d4a(%rip), %rcx     # 0x3ebc9
movl $0x326, %edx            # imm = 0x326
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %eax
testq %rax, %rax
je 0x2cebe
testl %eax, %eax
jle 0x2cf6d
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
addq 0x8(%rdi), %rcx
movq %rcx, %rdx
addq $-0x30, %rdx
je 0x2cebe
cmpl $0x0, (%rdx)
jne 0x2cebe
cmpq $0x0, -0x10(%rcx)
je 0x2cec4
popq %rbp
jmp 0x2cc3e
movl 0x50(%rdi), %edx
testq %rdx, %rdx
je 0x2cee5
testl %edx, %edx
jle 0x2cf8c
movq 0x58(%rdi), %rsi
shlq $0x4, %rdx
addq %rsi, %rdx
addq $-0x10, %rdx
jmp 0x2ceec
leaq 0x2c8a4(%rip), %rdx     # 0x59790
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
movss 0x8(%rdx), %xmm2
movss 0xc(%rdx), %xmm3
cmpl $0x1, %eax
je 0x2cf57
movss -0x5c(%rcx), %xmm4
movss -0x58(%rcx), %xmm5
subss %xmm0, %xmm4
subss %xmm1, %xmm5
movss -0x54(%rcx), %xmm6
subss %xmm2, %xmm6
movss -0x50(%rcx), %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 0x10468(%rip), %xmm4    # 0x3d3b4
ucomiss %xmm7, %xmm4
jbe 0x2cf57
decl %eax
movl %eax, (%rdi)
jmp 0x2cf6b
movss %xmm0, -0x2c(%rcx)
movss %xmm1, -0x28(%rcx)
movss %xmm2, -0x24(%rcx)
movss %xmm3, -0x20(%rcx)
popq %rbp
retq
leaq 0x19bc1(%rip), %rdi     # 0x46b35
leaq 0x11b48(%rip), %rsi     # 0x3eac3
leaq 0x11c47(%rip), %rcx     # 0x3ebc9
movl $0x326, %edx            # imm = 0x326
callq 0x7140
leaq 0x19ba2(%rip), %rdi     # 0x46b35
leaq 0x11b29(%rip), %rsi     # 0x3eac3
leaq 0x11da9(%rip), %rcx     # 0x3ed4a
jmp 0x2cf82
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %eax
testq %rax, %rax
je 0x2d0aa
testl %eax, %eax
jle 0x2d0e8
movq 0x8(%rdi), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x30, %rax
jmp 0x2d0ac
xorl %eax, %eax
movl 0x60(%rdi), %ecx
testq %rcx, %rcx
je 0x2d0c3
testl %ecx, %ecx
jle 0x2d0ff
movq 0x68(%rdi), %rdx
movq -0x8(%rdx,%rcx,8), %rcx
jmp 0x2d0c5
xorl %ecx, %ecx
testq %rax, %rax
je 0x2d0dc
cmpl $0x0, (%rax)
je 0x2d0d5
cmpq %rcx, 0x18(%rax)
jne 0x2d0dc
cmpq $0x0, 0x20(%rax)
je 0x2d0e2
popq %rbp
jmp 0x2cc3e
movq %rcx, 0x18(%rax)
popq %rbp
retq
leaq 0x19a46(%rip), %rdi     # 0x46b35
leaq 0x119cd(%rip), %rsi     # 0x3eac3
leaq 0x11acc(%rip), %rcx     # 0x3ebc9
jmp 0x2d114
leaq 0x19a2f(%rip), %rdi     # 0x46b35
leaq 0x119b6(%rip), %rsi     # 0x3eac3
leaq 0x1a1e3(%rip), %rcx     # 0x472f7
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addl %esi, -0x30(%rax,%rcx)
movslq 0x20(%rdi), %r13
addl %r13d, %r15d
movl 0x24(%rdi), %ecx
cmpl %r15d, %ecx
jge 0x2d9c4
testl %ecx, %ecx
je 0x2d9ca
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
addl %ecx, %eax
jmp 0x2d9cf
movq 0x28(%rbx), %r12
jmp 0x2da1c
movl $0x8, %eax
cmpl %r15d, %eax
cmovlel %r15d, %eax
cltq
movq %rax, -0x30(%rbp)
leaq (,%rax,4), %rax
leaq (%rax,%rax,4), %rdi
callq 0x8589
movq %rax, %r12
movq 0x28(%rbx), %rsi
movslq 0x20(%rbx), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r12, %rdi
callq 0x7080
movq 0x28(%rbx), %rdi
callq 0x9019
movq %r12, 0x28(%rbx)
movq -0x30(%rbp), %rax
movl %eax, 0x24(%rbx)
movl %r15d, 0x20(%rbx)
leaq (,%r13,4), %rax
addq %r13, %rax
leaq (%r12,%rax,4), %rax
movq %rax, 0x40(%rbx)
movslq 0x10(%rbx), %r12
addl %r12d, %r14d
movl 0x14(%rbx), %ecx
cmpl %r14d, %ecx
jge 0x2da53
testl %ecx, %ecx
je 0x2da59
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
addl %ecx, %eax
jmp 0x2da5e
movq 0x18(%rbx), %r15
jmp 0x2da9c
movl $0x8, %eax
cmpl %r14d, %eax
cmovlel %r14d, %eax
movslq %eax, %r13
leaq (,%r13,2), %rdi
callq 0x8589
movq %rax, %r15
movq 0x18(%rbx), %rsi
movslq 0x10(%rbx), %rdx
addq %rdx, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x18(%rbx), %rdi
callq 0x9019
movq %r15, 0x18(%rbx)
movl %r13d, 0x14(%rbx)
movl %r14d, 0x10(%rbx)
leaq (%r15,%r12,2), %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f8b5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movss 0xdcb4(%rip), %xmm2     # 0x3d3cc
movss (%rsi), %xmm3
addss %xmm2, %xmm3
movss 0x4(%rsi), %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movl 0x70(%rdi), %eax
cmpl 0x74(%rdi), %eax
movss %xmm0, -0x2c(%rbp)
jne 0x2f751
leal 0x1(%rax), %ecx
testl %eax, %eax
movaps %xmm3, -0x40(%rbp)
je 0x2f757
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2f75c
movq 0x78(%rbx), %r12
jmp 0x2f7ad
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r13
leaq (,%r13,8), %rdi
callq 0x8589
movq %rax, %r12
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r12, 0x78(%rbx)
movl %r13d, 0x74(%rbx)
movl 0x70(%rbx), %eax
movss -0x2c(%rbp), %xmm0
movss 0xdc23(%rip), %xmm2     # 0x3d3cc
movaps -0x40(%rbp), %xmm3
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cltq
movlps %xmm3, (%r12,%rax,8)
movss (%r15), %xmm1
addss %xmm2, %xmm1
addss 0x4(%r15), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movl 0x70(%rbx), %eax
cmpl 0x74(%rbx), %eax
jne 0x2f7ec
leal 0x1(%rax), %ecx
testl %eax, %eax
movaps %xmm1, -0x40(%rbp)
je 0x2f7f2
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2f7f7
movq 0x78(%rbx), %r15
jmp 0x2f840
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r12
leaq (,%r12,8), %rdi
callq 0x8589
movq %rax, %r15
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r15, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movl 0x70(%rbx), %eax
movss -0x2c(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cltq
movlps %xmm1, (%r15,%rax,8)
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x2dc76
cmpl $0x0, 0x74(%rbx)
jns 0x2f8a0
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_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 0x2f982
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
movss 0xdaf1(%rip), %xmm1     # 0x3d3cc
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 0x2f316
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movss 0xda6c(%rip), %xmm0     # 0x3d390
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x2dc76
cmpl $0x0, 0x74(%rbx)
jns 0x2f973
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    if (rounding > 0.0f)
    {
        PathRect(a, b, rounding, rounding_corners);
        PathFill(col);
    }
    else
    {
        PrimReserve(6, 4);
        PrimRect(a, b, col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x2fa10
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2fa19
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x2f316
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
callq 0x2e5dc
cmpl $0x0, 0x74(%rbx)
jns 0x2fa09
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x6, %esi
movl $0x4, %edx
callq 0x2d97a
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2dab8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fb69
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdi, %rbx
leaq 0x25a04(%rip), %rax     # 0x55480
movq (%rax), %rax
movq 0x1720(%rax), %r15
movq %rsi, -0x30(%rbp)
movl $0x6, %esi
movq %rdx, -0x38(%rbp)
movl $0x4, %edx
callq 0x2d97a
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 0x40(%rbx), %rax
movq -0x30(%rbp), %rdi
movq (%rdi), %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r14d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movq -0x38(%rbp), %rsi
movl (%rsi), %ecx
movl 0x4(%rdi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r13d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x14(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r12d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movl (%rdi), %ecx
movl 0x4(%rsi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x14, %rax
movq %rax, 0x40(%rbx)
incl 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x2fd7d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rsi, %r13
movq %rdi, %rbx
movq %rcx, -0x38(%rbp)
movl 0x70(%rdi), %eax
cmpl 0x74(%rdi), %eax
jne 0x2fbc3
movq %rdx, -0x30(%rbp)
leal 0x1(%rax), %ecx
testl %eax, %eax
je 0x2fbc9
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2fbce
movq 0x78(%rbx), %r15
jmp 0x2fc12
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r12
leaq (,%r12,8), %rdi
callq 0x8589
movq %rax, %r15
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r15, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movl 0x70(%rbx), %eax
movq -0x30(%rbp), %rdx
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cltq
movq (%r13), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x70(%rbx), %eax
cmpl 0x74(%rbx), %eax
jne 0x2fc41
movq %rdx, %r13
leal 0x1(%rax), %ecx
testl %eax, %eax
je 0x2fc47
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2fc4c
movq 0x78(%rbx), %r15
jmp 0x2fc8f
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r12
leaq (,%r12,8), %rdi
callq 0x8589
movq %rax, %r15
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r15, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movl 0x70(%rbx), %eax
movq %r13, %rdx
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cltq
movq (%rdx), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x70(%rbx), %eax
cmpl 0x74(%rbx), %eax
jne 0x2fcba
leal 0x1(%rax), %ecx
testl %eax, %eax
je 0x2fcc0
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2fcc5
movq 0x78(%rbx), %r15
jmp 0x2fd05
movl $0x8, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movslq %ecx, %r12
leaq (,%r12,8), %rdi
callq 0x8589
movq %rax, %r15
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r15, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cltq
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
callq 0x2e5dc
cmpl $0x0, 0x74(%rbx)
jns 0x2fd68
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircle(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x2fe26
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0xd5f9(%rip), %xmm2     # 0x3d39c
addss %xmm1, %xmm2
mulss 0xd6a9(%rip), %xmm2     # 0x3d458
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2eb98
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movss 0xd5c4(%rip), %xmm0     # 0x3d390
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x2dc76
cmpl $0x0, 0x74(%rbx)
jns 0x2fe1b
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircleFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x2fec2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0xd54f(%rip), %xmm2     # 0x3d39c
addss %xmm1, %xmm2
mulss 0xd5ff(%rip), %xmm2     # 0x3d458
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2eb98
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
callq 0x2e5dc
cmpl $0x0, 0x74(%rbx)
jns 0x2feb7
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierCurve(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments) 
{ 
    if ((col >> 24) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %r9d        # imm = 0x1000000
jb 0x30007
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x10(%rbp), %r9d
movl 0x70(%rdi), %eax
cmpl 0x74(%rdi), %eax
movss %xmm0, -0x2c(%rbp)
jne 0x2ff1c
leal 0x1(%rax), %esi
testl %eax, %eax
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
je 0x2ff22
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x2ff27
movq 0x78(%rbx), %r12
jmp 0x2ff77
movl $0x8, %edx
cmpl %esi, %edx
cmovgl %edx, %esi
movslq %esi, %r13
leaq (,%r13,8), %rdi
callq 0x8589
movq %rax, %r12
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r12, 0x78(%rbx)
movl %r13d, 0x74(%rbx)
movl 0x70(%rbx), %eax
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl 0x10(%rbp), %r9d
leal 0x1(%rax), %esi
movl %esi, 0x70(%rbx)
cltq
movq (%r15), %rsi
movq %rsi, (%r12,%rax,8)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x2edd4
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x2c(%rbp), %xmm0
movl $0x1, %r9d
callq 0x2dc76
cmpl $0x0, 0x74(%rbx)
jns 0x2fff2
xorl %edi, %edi
callq 0x8589
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9019
movq %r14, 0x78(%rbx)
movl $0x0, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddImage(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col)
{
    if ((col >> 24) == 0)
        return;

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

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

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rbp), %r15d
movq %rsi, -0x38(%rbp)
cmpl $0x1000000, %r15d       # imm = 0x1000000
jae 0x3093b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movq %r9, -0x30(%rbp)
movl 0x60(%rdi), %eax
testq %rax, %rax
je 0x30967
testl %eax, %eax
jle 0x309eb
movq 0x68(%r12), %rcx
cmpq %rsi, -0x8(%rcx,%rax,8)
je 0x309b3
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
callq 0x2d11e
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x2d97a
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
callq 0x2db84
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d1b6
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x2d97a
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2db84
leaq 0x16143(%rip), %rdi     # 0x46b35
leaq 0xe0ca(%rip), %rsi      # 0x3eac3
leaq 0x168f7(%rip), %rcx     # 0x472f7
movl $0x326, %edx            # imm = 0x326
callq 0x7140