LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowDemoWindowTables()::MyTreeNode::DisplayNode(MyTreeNode const*, MyTreeNode const*)
static void DisplayNode(const MyTreeNode* node, const MyTreeNode* all_nodes)
                {
                    ImGui::TableNextRow();
                    ImGui::TableNextColumn();
                    const bool is_folder = (node->ChildCount > 0);
                    if (is_folder)
                    {
                        bool open = ImGui::TreeNodeEx(node->Name, ImGuiTreeNodeFlags_SpanFullWidth);
                        ImGui::TableNextColumn();
                        ImGui::TextDisabled("--");
                        ImGui::TableNextColumn();
                        ImGui::TextUnformatted(node->Type);
                        if (open)
                        {
                            for (int child_n = 0; child_n < node->ChildCount; child_n++)
                                DisplayNode(&all_nodes[node->ChildIdx + child_n], all_nodes);
                            ImGui::TreePop();
                        }
                    }
                    else
                    {
                        ImGui::TreeNodeEx(node->Name, ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_Bullet | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth);
                        ImGui::TableNextColumn();
                        ImGui::Text("%d", node->Size);
                        ImGui::TableNextColumn();
                        ImGui::TextUnformatted(node->Type);
                    }
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
xorps %xmm0, %xmm0
callq 0x131530
callq 0x131d40
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
setg %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x107dd3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x151f80
andb $0x1, %al
movb %al, -0x12(%rbp)
callq 0x131d40
leaq 0x8699b(%rip), %rdi     # 0x18e706
movb $0x0, %al
callq 0x1393f0
callq 0x131d40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
testb $0x1, -0x12(%rbp)
je 0x107dd1
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x107dcc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl -0x18(%rbp), %eax
cltq
shlq $0x5, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x107d10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x107d95
callq 0x1523d0
jmp 0x107e14
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1308, %esi           # imm = 0x1308
callq 0x151f80
callq 0x131d40
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x71bd0(%rip), %rdi     # 0x1799c7
movb $0x0, %al
callq 0x139160
callq 0x131d40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: NotifyOfDocumentsClosedElsewhere(ExampleAppDocuments&)
static void NotifyOfDocumentsClosedElsewhere(ExampleAppDocuments& app)
{
    for (int doc_n = 0; doc_n < app.Documents.Size; doc_n++)
    {
        MyDocument* doc = &app.Documents[doc_n];
        if (!doc->Open && doc->OpenPrev)
            ImGui::SetTabItemClosed(doc->Name);
        doc->OpenPrev = doc->Open;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x108f7a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10bc30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x108f5e
movq -0x18(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x108f5e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x158c60
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x9(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x108f23
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ExampleAppConsole::ExampleAppConsole()
ExampleAppConsole()
    {
        ClearLog();
        memset(InputBuf, 0, sizeof(InputBuf));
        HistoryPos = -1;

        // "CLASSIFY" is here to provide the test case where "C"+[tab] completes to "CL" and display multiple matches.
        Commands.push_back("HELP");
        Commands.push_back("HISTORY");
        Commands.push_back("CLEAR");
        Commands.push_back("CLASSIFY");
        AutoScroll = true;
        ScrollToBottom = false;
        AddLog("Welcome to Dear ImGui!");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq %rdi, -0x50(%rbp)
callq 0x109d70
movq -0x48(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq %rdi, -0x40(%rbp)
callq 0x109da0
jmp 0x10955a
movq -0x48(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x58(%rbp)
callq 0x109d70
jmp 0x109570
movq -0x48(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq %rdi, -0x60(%rbp)
leaq 0x68983(%rip), %rsi     # 0x171f09
callq 0xc65d0
jmp 0x10958d
movq -0x48(%rbp), %rdi
callq 0x109dd0
jmp 0x109598
movq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movups %xmm0, 0xf0(%rdi)
movups %xmm0, 0xe0(%rdi)
movups %xmm0, 0xd0(%rdi)
movups %xmm0, 0xc0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0xffffffff, 0x130(%rdi) # imm = 0xFFFFFFFF
addq $0x110, %rdi            # imm = 0x110
leaq 0x79335(%rip), %rax     # 0x182947
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x109e40
jmp 0x109621
movq -0x48(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq 0x79319(%rip), %rax     # 0x18294c
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x109e40
jmp 0x109642
movq -0x48(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq 0x79300(%rip), %rax     # 0x182954
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x109e40
jmp 0x109663
movq -0x48(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq 0x792e5(%rip), %rax     # 0x18295a
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x109e40
jmp 0x109684
movq -0x48(%rbp), %rdi
movb $0x1, 0x250(%rdi)
movb $0x0, 0x251(%rdi)
leaq 0x792c6(%rip), %rsi     # 0x182963
xorl %eax, %eax
callq 0x109ea0
jmp 0x1096a6
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1096fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1096f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1096eb
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x108fc0
movq -0x58(%rbp), %rdi
callq 0x109fb0
movq -0x40(%rbp), %rdi
callq 0x109ff0
movq -0x50(%rbp), %rdi
callq 0x109fb0
movq -0x10(%rbp), %rdi
callq 0xd620
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: MyDocument::DisplayContextMenu(MyDocument*)
static void DisplayContextMenu(MyDocument* doc)
    {
        if (!ImGui::BeginPopupContextItem())
            return;

        char buf[256];
        sprintf(buf, "Save %s", doc->Name);
        if (ImGui::MenuItem(buf, "CTRL+S", false, doc->Open))
            doc->DoSave();
        if (ImGui::MenuItem("Close", "CTRL+W", false, doc->Open))
            doc->DoQueueClose();
        ImGui::EndPopup();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xde8a0
testb $0x1, %al
jne 0x10bd36
jmp 0x10bdb7
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x77b08(%rip), %rsi     # 0x183853
movb $0x0, %al
callq 0xd990
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
leaq 0x77af4(%rip), %rsi     # 0x18385b
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x155360
testb $0x1, %al
jne 0x10bd79
jmp 0x10bd82
movq -0x8(%rbp), %rdi
callq 0x10c070
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
leaq 0x71bcd(%rip), %rdi     # 0x17d95d
leaq 0x77acb(%rip), %rsi     # 0x183862
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x155360
testb $0x1, %al
jne 0x10bda9
jmp 0x10bdb2
movq -0x8(%rbp), %rdi
callq 0x10bcd0
callq 0xde4e0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: MyDocument::DisplayContents(MyDocument*)
static void DisplayContents(MyDocument* doc)
    {
        ImGui::PushID(doc);
        ImGui::Text("Document \"%s\"", doc->Name);
        ImGui::PushStyleColor(ImGuiCol_Text, doc->Color);
        ImGui::TextWrapped("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
        ImGui::PopStyleColor();
        if (ImGui::Button("Modify", ImVec2(100, 0)))
            doc->Dirty = true;
        ImGui::SameLine();
        if (ImGui::Button("Save", ImVec2(100, 0)))
            doc->DoSave();
        ImGui::ColorEdit3("color", &doc->Color.x);  // Useful to test drag and drop and hold-dragged-to-open-tab behavior.
        ImGui::PopID();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdb500
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x77a86(%rip), %rdi     # 0x183869
movb $0x0, %al
callq 0x139160
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
xorl %edi, %edi
callq 0xc78f0
leaq 0x77a77(%rip), %rdi     # 0x183877
movb $0x0, %al
callq 0x139570
movl $0x1, %edi
callq 0xc7990
leaq -0x10(%rbp), %rdi
movss 0x6695b(%rip), %xmm0    # 0x172778
xorps %xmm1, %xmm1
callq 0xbf4c0
leaq 0x77ac7(%rip), %rdi     # 0x1838f3
leaq -0x10(%rbp), %rsi
callq 0x13a930
testb $0x1, %al
jne 0x10be3b
jmp 0x10be43
movq -0x8(%rbp), %rax
movb $0x1, 0xa(%rax)
xorps %xmm0, %xmm0
movss 0x66132(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq -0x18(%rbp), %rdi
movss 0x66919(%rip), %xmm0    # 0x172778
xorps %xmm1, %xmm1
callq 0xbf4c0
leaq 0x6e414(%rip), %rdi     # 0x17a282
leaq -0x18(%rbp), %rsi
callq 0x13a930
testb $0x1, %al
jne 0x10be7d
jmp 0x10be86
movq -0x8(%rbp), %rdi
callq 0x10c070
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
leaq 0x74ac3(%rip), %rdi     # 0x180958
xorl %edx, %edx
callq 0x14be70
callq 0xdb640
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: MyDocument::MyDocument(char const*, bool, ImVec4 const&)
MyDocument(const char* name, bool open = true, const ImVec4& color = ImVec4(1.0f, 1.0f, 1.0f, 1.0f))
    {
        Name = name;
        Open = OpenPrev = open;
        Dirty = false;
        WantClose = false;
        Color = color;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xc, %rdi
callq 0xe7e00
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movb -0x11(%rbp), %cl
movb %cl, %dl
andb $0x1, %dl
movb %dl, 0x9(%rax)
andb $0x1, %cl
movb %cl, 0x8(%rax)
movb $0x0, 0xa(%rax)
movb $0x0, 0xb(%rax)
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0xc(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSharedData::ImDrawListSharedData()
ImDrawListSharedData::ImDrawListSharedData()
{
    memset(this, 0, sizeof(*this));
    for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)
    {
        const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);
        ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe7de0
movq -0x30(%rbp), %rdi
addq $0x1c, %rdi
callq 0xe7e00
movq -0x30(%rbp), %rax
addq $0x30, %rax
movq %rax, %rcx
addq $0x60, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe7de0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0x10eb8d
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0xd8, %edx
callq 0xd2f0
movl $0x0, -0xc(%rbp)
cmpl $0xc, -0xc(%rbp)
jge 0x10ec40
cvtsi2ssl -0xc(%rbp), %xmm0
movss 0x633f3(%rip), %xmm1    # 0x171fcc
mulss %xmm1, %xmm0
movss 0x63bb3(%rip), %xmm1    # 0x172798
mulss %xmm1, %xmm0
movss 0x63be3(%rip), %xmm1    # 0x1727d4
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
callq 0xd6a0
movss %xmm0, -0x3c(%rbp)
movss -0x10(%rbp), %xmm0
callq 0xd070
movaps %xmm0, %xmm1
movss -0x3c(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0xbf4c0
movq -0x30(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10ebc6
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSharedData::SetCircleSegmentMaxError(float)
void ImDrawListSharedData::SetCircleSegmentMaxError(float max_error)
{
    if (CircleSegmentMaxError == max_error)
        return;
    CircleSegmentMaxError = max_error;
    for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)
    {
        const float radius = (float)i;
        const int segment_count = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, CircleSegmentMaxError);
        CircleSegmentCounts[i] = (ImU8)ImMin(segment_count, 255);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x18(%rax), %xmm0
ucomiss -0xc(%rbp), %xmm0
jne 0x10ec7b
jp 0x10ec7b
jmp 0x10ed08
movq -0x20(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x18(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jge 0x10ed08
movq -0x20(%rbp), %rax
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
subss 0x18(%rax), %xmm0
divss -0x14(%rbp), %xmm0
callq 0xd590
movaps %xmm0, %xmm1
movss 0x74d41(%rip), %xmm0    # 0x183a04
divss %xmm1, %xmm0
cvttss2si %xmm0, %edi
movl $0xc, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x10ed10
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl $0xff, %esi
callq 0x10ed50
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movslq -0x10(%rbp), %rcx
movb %dl, 0x90(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10ec90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_ResetForNewFrame()
void ImDrawList::_ResetForNewFrame()
{
    // Verify that the ImDrawCmd fields we want to memcmp() are contiguous in memory.
    // (those should be IM_STATIC_ASSERT() in theory but with our pre C++11 setup the whole check doesn't compile with GCC)
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, ClipRect) == 0);
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, TextureId) == sizeof(ImVec4));
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, VtxOffset) == sizeof(ImVec4) + sizeof(ImTextureID));

    CmdBuffer.resize(0);
    IdxBuffer.resize(0);
    VtxBuffer.resize(0);
    Flags = _Data->InitialFlags;
    memset(&_CmdHeader, 0, sizeof(_CmdHeader));
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.resize(0);
    _TextureIdStack.resize(0);
    _Path.resize(0);
    _Splitter.Clear();
    CmdBuffer.push_back(ImDrawCmd());
    _FringeScale = 1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
callq 0x126c60
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0xe7f00
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x126cb0
movq -0x48(%rbp), %rdi
movq 0x38(%rdi), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x30(%rdi)
addq $0x88, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd2f0
movq -0x48(%rbp), %rdi
movl $0x0, 0x34(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
addq $0x58, %rdi
xorl %esi, %esi
callq 0x126d00
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
callq 0x126d50
movq -0x48(%rbp), %rdi
addq $0x78, %rdi
xorl %esi, %esi
callq 0x10b830
movq -0x48(%rbp), %rdi
addq $0xa8, %rdi
callq 0x126da0
leaq -0x40(%rbp), %rdi
callq 0x126e30
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x126dc0
movq -0x48(%rbp), %rax
movss 0x61dec(%rip), %xmm0    # 0x170c3c
movss %xmm0, 0xc0(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_ClearFreeMemory()
void ImDrawList::_ClearFreeMemory()
{
    CmdBuffer.clear();
    IdxBuffer.clear();
    VtxBuffer.clear();
    Flags = ImDrawListFlags_None;
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.clear();
    _TextureIdStack.clear();
    _Path.clear();
    _Splitter.ClearFreeMemory();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x126e60
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xedfe0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x126eb0
movq -0x10(%rbp), %rdi
movl $0x0, 0x30(%rdi)
movl $0x0, 0x34(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
addq $0x58, %rdi
callq 0x126f00
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x126f50
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x10b890
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0x10eef0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSplitter::ClearFreeMemory()
void ImDrawListSplitter::ClearFreeMemory()
{
    for (int i = 0; i < _Channels.Size; i++)
    {
        if (i == _Current)
            memset(&_Channels[i], 0, sizeof(_Channels[i]));  // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again
        _Channels[i]._CmdBuffer.clear();
        _Channels[i]._IdxBuffer.clear();
    }
    _Current = 0;
    _Count = 1;
    _Channels.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x10ef80
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jne 0x10ef41
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0x127430
movq %rax, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd2f0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0x127430
movq %rax, %rdi
callq 0x126e60
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0x127430
movq %rax, %rdi
addq $0x10, %rdi
callq 0xedfe0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10ef0b
movq -0x18(%rbp), %rdi
movl $0x0, (%rdi)
movl $0x1, 0x4(%rdi)
addq $0x8, %rdi
callq 0xeb010
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::CloneOutput() const
ImDrawList* ImDrawList::CloneOutput() const
{
    ImDrawList* dst = IM_NEW(ImDrawList(_Data));
    dst->CmdBuffer = CmdBuffer;
    dst->IdxBuffer = IdxBuffer;
    dst->VtxBuffer = VtxBuffer;
    dst->Flags = Flags;
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xc8, %edi
movq %rdi, -0x48(%rbp)
callq 0xc4820
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq %rsi, %rax
movq %rax, -0x40(%rbp)
callq 0xe9510
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0x38(%rax), %rsi
callq 0xe8d10
jmp 0x10efee
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x126fa0
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x127000
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x127060
movq -0x38(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xea550
movq -0x20(%rbp), %rdi
callq 0xd620
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddDrawCmd()
void ImDrawList::AddDrawCmd()
{
    ImDrawCmd draw_cmd;
    draw_cmd.ClipRect = _CmdHeader.ClipRect;    // Same as calling ImDrawCmd_HeaderCopy()
    draw_cmd.TextureId = _CmdHeader.TextureId;
    draw_cmd.VtxOffset = _CmdHeader.VtxOffset;
    draw_cmd.IdxOffset = IdxBuffer.Size;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x126e30
movq -0x50(%rbp), %rax
movq 0x88(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x90(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x98(%rax), %rcx
movq %rcx, -0x30(%rbp)
movl 0xa0(%rax), %ecx
movl %ecx, -0x28(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movss -0x40(%rbp), %xmm1
movss -0x38(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x41(%rbp)
jb 0x10f0e8
movss -0x3c(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x10f0f1
jmp 0x10f0f3
jmp 0x10f112
leaq 0x7b023(%rip), %rdi     # 0x18a11d
leaq 0x7b075(%rip), %rsi     # 0x18a176
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0x7b086(%rip), %rcx     # 0x18a193
callq 0xd180
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x126dc0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_PopUnusedDrawCmd()
void ImDrawList::_PopUnusedDrawCmd()
{
    if (CmdBuffer.Size == 0)
        return;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount == 0 && curr_cmd->UserCallback == NULL)
        CmdBuffer.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x10f14b
jmp 0x10f184
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x10f184
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f184
movq -0x18(%rbp), %rdi
callq 0x1270c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*)
void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    }
    curr_cmd->UserCallback = callback;
    curr_cmd->UserCallbackData = callback_data;

    AddDrawCmd(); // Force a new command after us (see comment below)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f1d0
jmp 0x10f1ef
leaq 0x7afda(%rip), %rdi     # 0x18a1b1
leaq 0x7af98(%rip), %rsi     # 0x18a176
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x7afe8(%rip), %rcx     # 0x18a1d2
callq 0xd180
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x10f21d
movq -0x28(%rbp), %rdi
callq 0x10f070
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
callq 0x10f070
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedClipRect()
void ImDrawList::_OnChangedClipRect()
{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }

    curr_cmd->ClipRect = _CmdHeader.ClipRect;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x10f2c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x88, %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10f2c0
movq -0x20(%rbp), %rdi
callq 0x10f070
jmp 0x10f35c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f2cd
jmp 0x10f2ec
leaq 0x7aedd(%rip), %rdi     # 0x18a1b1
leaq 0x7ae9b(%rip), %rsi     # 0x18a176
movl $0x1ea, %edx            # imm = 0x1EA
leaq 0x7af20(%rip), %rcx     # 0x18a207
callq 0xd180
movq -0x10(%rbp), %rax
addq $-0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x10f33f
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jle 0x10f33f
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
movl $0x1c, %edx
callq 0xd9f0
cmpl $0x0, %eax
jne 0x10f33f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f33f
movq -0x20(%rbp), %rdi
callq 0x1270c0
jmp 0x10f35c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x88(%rcx), %rdx
movq %rdx, (%rax)
movq 0x90(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedTextureID()
void ImDrawList::_OnChangedTextureID()
{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != _CmdHeader.TextureId)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }

    curr_cmd->TextureId = _CmdHeader.TextureId;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x10f3c8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x98(%rcx), %rax
je 0x10f3c8
movq -0x20(%rbp), %rdi
callq 0x10f070
jmp 0x10f45a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f3d5
jmp 0x10f3f4
leaq 0x7add5(%rip), %rdi     # 0x18a1b1
leaq 0x7ad93(%rip), %rsi     # 0x18a176
movl $0x200, %edx            # imm = 0x200
leaq 0x7ae3e(%rip), %rcx     # 0x18a22d
callq 0xd180
movq -0x10(%rbp), %rax
addq $-0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x10f447
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jle 0x10f447
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
movl $0x1c, %edx
callq 0xd9f0
cmpl $0x0, %eax
jne 0x10f447
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f447
movq -0x20(%rbp), %rdi
callq 0x1270c0
jmp 0x10f45a
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedVtxOffset()
void ImDrawList::_OnChangedVtxOffset()
{
    // We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.
    _VtxCurrentIdx = 0;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    //IM_ASSERT(curr_cmd->VtxOffset != _CmdHeader.VtxOffset); // See #3349
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    curr_cmd->VtxOffset = _CmdHeader.VtxOffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x0, 0x34(%rcx)
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x10f4a7
movq -0x18(%rbp), %rdi
callq 0x10f070
jmp 0x10f4e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x10f4b4
jmp 0x10f4d3
leaq 0x7acf6(%rip), %rdi     # 0x18a1b1
leaq 0x7acb4(%rip), %rsi     # 0x18a176
movl $0x218, %edx            # imm = 0x218
leaq 0x7ad86(%rip), %rcx     # 0x18a254
callq 0xd180
movq -0x18(%rbp), %rax
movl 0xa0(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PushClipRect(ImVec2, ImVec2, bool)
void ImDrawList::PushClipRect(ImVec2 cr_min, ImVec2 cr_max, bool intersect_with_current_clip_rect)
{
    ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);
    if (intersect_with_current_clip_rect)
    {
        ImVec4 current = _CmdHeader.ClipRect;
        if (cr.x < current.x) cr.x = current.x;
        if (cr.y < current.y) cr.y = current.y;
        if (cr.z > current.z) cr.z = current.z;
        if (cr.w > current.w) cr.w = current.w;
    }
    cr.z = ImMax(cr.x, cr.z);
    cr.w = ImMax(cr.y, cr.w);

    _ClipRectStack.push_back(cr);
    _CmdHeader.ClipRect = cr;
    _OnChangedClipRect();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movss -0x8(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movss -0x10(%rbp), %xmm2
movss -0xc(%rbp), %xmm3
leaq -0x2c(%rbp), %rdi
callq 0xbf4f0
testb $0x1, -0x19(%rbp)
je 0x10f5b1
movq -0x48(%rbp), %rax
movq 0x88(%rax), %rcx
movq %rcx, -0x3c(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x34(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x3c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x10f56c
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x38(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x10f585
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x34(%rbp), %xmm0
jbe 0x10f59a
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0x10f5af
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x10f5b1
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x10f610
movss %xmm0, -0x24(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
callq 0x10f610
movq -0x48(%rbp), %rdi
movss %xmm0, -0x20(%rbp)
addq $0x58, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x127110
movq -0x48(%rbp), %rdi
movq -0x2c(%rbp), %rax
movq %rax, 0x88(%rdi)
movq -0x24(%rbp), %rax
movq %rax, 0x90(%rdi)
callq 0x10f250
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimReserve(int, int)
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
{
    // Large mesh support (when enabled)
    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
    if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
    {
        // FIXME: In theory we should be testing that vtx_count <64k here.
        // In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us
        // to not make that check until we rework the text functions to handle clipping and large horizontal lines better.
        _CmdHeader.VtxOffset = VtxBuffer.Size;
        _OnChangedVtxOffset();
    }

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    draw_cmd->ElemCount += idx_count;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x34(%rax), %eax
addl -0x10(%rbp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x10f838
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10f838
movq -0x28(%rbp), %rdi
movl 0x20(%rdi), %eax
movl %eax, 0xa0(%rdi)
callq 0x10f460
movq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl 0x20(%rdi), %eax
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movl -0x1c(%rbp), %esi
addl -0x10(%rbp), %esi
callq 0x126cb0
movq -0x28(%rbp), %rdi
movq 0x28(%rdi), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rdi)
movl 0x10(%rdi), %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
movl -0x20(%rbp), %esi
addl -0xc(%rbp), %esi
callq 0xe7f00
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x20(%rbp), %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimUnreserve(int, int)
void ImDrawList::PrimUnreserve(int idx_count, int vtx_count)
{
    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    draw_cmd->ElemCount -= idx_count;
    VtxBuffer.shrink(VtxBuffer.Size - vtx_count);
    IdxBuffer.shrink(IdxBuffer.Size - idx_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
movl (%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %edx
subl %esi, %edx
movl %edx, 0x20(%rcx)
movq %rax, %rdi
addq $0x20, %rdi
movl 0x20(%rax), %esi
subl -0x10(%rbp), %esi
callq 0x127280
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movl 0x10(%rax), %esi
subl -0xc(%rbp), %esi
callq 0x1272d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRect(ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
{
    ImVec2 b(c.x, a.y), d(a.x, c.y), uv(_Data->TexUvWhitePixel);
    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x24(%rbp), %rdi
callq 0xbf4c0
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
leaq -0x2c(%rbp), %rdi
callq 0xbf4c0
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x34(%rbp)
movl 0x34(%rax), %ecx
movw %cx, -0x36(%rbp)
movw -0x36(%rbp), %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movzwl -0x36(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movzwl -0x36(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movw -0x36(%rbp), %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movzwl -0x36(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movzwl -0x36(%rbp), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movq -0x10(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq 0x48(%rax), %rcx
movq -0x34(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x1c(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq 0x48(%rax), %rcx
movq -0x24(%rbp), %rdx
movq %rdx, 0x14(%rcx)
movq 0x48(%rax), %rcx
movq -0x34(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x1c(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x18(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x28(%rcx)
movq 0x48(%rax), %rcx
movq -0x34(%rbp), %rdx
movq %rdx, 0x30(%rcx)
movl -0x1c(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x38(%rcx)
movq 0x48(%rax), %rcx
movq -0x2c(%rbp), %rdx
movq %rdx, 0x3c(%rcx)
movq 0x48(%rax), %rcx
movq -0x34(%rbp), %rdx
movq %rdx, 0x44(%rcx)
movl -0x1c(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x4c(%rcx)
movq 0x48(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x48(%rax)
movl 0x34(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x34(%rax)
movq 0x50(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimQuadUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)
{
    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movw %cx, -0x32(%rbp)
movw -0x32(%rbp), %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movzwl -0x32(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movzwl -0x32(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movw -0x32(%rbp), %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movzwl -0x32(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movzwl -0x32(%rbp), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movq -0x10(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq -0x30(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x8(%rcx)
movl 0x28(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq -0x18(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x14(%rcx)
movq 0x10(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x1c(%rcx)
movl 0x28(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x20(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x28(%rcx)
movq 0x18(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x30(%rcx)
movl 0x28(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x38(%rcx)
movq -0x28(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x3c(%rcx)
movq 0x20(%rbp), %rdx
movq 0x48(%rax), %rcx
movq (%rdx), %rdx
movq %rdx, 0x44(%rcx)
movl 0x28(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x4c(%rcx)
movq 0x48(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x48(%rax)
movl 0x34(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x34(%rax)
movq 0x50(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x50(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PathArcToFast(ImVec2 const&, float, int, int)
void ImDrawList::PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12)
{
    if (radius == 0.0f || a_min_of_12 > a_max_of_12)
    {
        _Path.push_back(center);
        return;
    }

    // For legacy reason the PathArcToFast() always takes angles where 2*PI is represented by 12,
    // but it is possible to set IM_DRAWLIST_ARCFAST_TESSELATION_MULTIPLIER to a higher value. This should compile to a no-op otherwise.
#if IM_DRAWLIST_ARCFAST_TESSELLATION_MULTIPLIER != 1
    a_min_of_12 *= IM_DRAWLIST_ARCFAST_TESSELLATION_MULTIPLIER;
    a_max_of_12 *= IM_DRAWLIST_ARCFAST_TESSELLATION_MULTIPLIER;
#endif

    _Path.reserve(_Path.Size + (a_max_of_12 - a_min_of_12 + 1));
    for (int a = a_min_of_12; a <= a_max_of_12; a++)
    {
        const ImVec2& c = _Data->ArcFastVtx[a % IM_ARRAYSIZE(_Data->ArcFastVtx)];
        _Path.push_back(ImVec2(center.x + c.x * radius, center.y + c.y * radius));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x111dd4
jp 0x111dd4
jmp 0x111ddc
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x111df2
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xee5d0
jmp 0x111eb3
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movl 0x78(%rax), %esi
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
addl %eax, %esi
callq 0xee630
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x111eb3
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x30, %rcx
movl -0x20(%rbp), %eax
movl $0xc, %esi
cltd
idivl %esi
movq -0x38(%rbp), %rax
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
addq $0x78, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm2
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm1
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x30(%rbp), %rdi
callq 0xbf4c0
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xee5d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x111e16
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PathArcTo(ImVec2 const&, float, float, float, int)
void ImDrawList::PathArcTo(const ImVec2& center, float radius, float a_min, float a_max, int num_segments)
{
    if (radius == 0.0f)
    {
        _Path.push_back(center);
        return;
    }

    // Note that we are adding a point at both a_min and a_max.
    // If you are trying to draw a full closed circle you don't want the overlapping points!
    _Path.reserve(_Path.Size + (num_segments + 1));
    for (int i = 0; i <= num_segments; i++)
    {
        const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min);
        _Path.push_back(ImVec2(center.x + ImCos(a) * radius, center.y + ImSin(a) * radius));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x111f0f
jp 0x111f0f
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xee5d0
jmp 0x111ff7
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movl 0x78(%rax), %esi
movl -0x20(%rbp), %eax
addl $0x1, %eax
addl %eax, %esi
callq 0xee630
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x111ff7
movq -0x38(%rbp), %rax
movss -0x18(%rbp), %xmm1
cvtsi2ssl -0x24(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm2
divss %xmm2, %xmm0
movss -0x1c(%rbp), %xmm2
subss -0x18(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
addq $0x78, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x28(%rbp), %xmm0
callq 0xd6a0
movss -0x4c(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x28(%rbp), %xmm0
callq 0xd070
movss -0x48(%rbp), %xmm2
movaps %xmm0, %xmm1
movss -0x44(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x30(%rbp), %rdi
callq 0xbf4c0
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xee5d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x111f31
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)