// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::BeginMenu(char const*, bool)
bool ImGui::BeginMenu(const char* label, bool enabled)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const ImGuiID id = window->GetID(label);
    bool menu_is_open = IsPopupOpen(id, ImGuiPopupFlags_None);

    // Sub-menus are ChildWindow so that mouse can be hovering across them (otherwise top-most popup menu would steal focus and not allow hovering on parent menu)
    ImGuiWindowFlags flags = ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNavFocus;
    if (window->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu))
        flags |= ImGuiWindowFlags_ChildWindow;

    // If a menu with same the ID was already submitted, we will append to it, matching the behavior of Begin().
    // We are relying on a O(N) search - so O(N log N) over the frame - which seems like the most efficient for the expected small amount of BeginMenu() calls per frame.
    // If somehow this is ever becoming a problem we can switch to use e.g. ImGuiStorage mapping key to last frame used.
    if (g.MenusIdSubmittedThisFrame.contains(id))
    {
        if (menu_is_open)
            menu_is_open = BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
        else
            g.NextWindowData.ClearFlags();          // we behave like Begin() and need to consume those values
        return menu_is_open;
    }

    // Tag menu as used. Next time BeginMenu() with same ID is called it will append to existing menu
    g.MenusIdSubmittedThisFrame.push_back(id);

    ImVec2 label_size = CalcTextSize(label, NULL, true);
    bool pressed;
    bool menuset_is_open = !(window->Flags & ImGuiWindowFlags_Popup) && (g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].OpenParentId == window->IDStack.back());
    ImGuiWindow* backed_nav_window = g.NavWindow;
    if (menuset_is_open)
        g.NavWindow = window;  // Odd hack to allow hovering across menus of a same menu-set (otherwise we wouldn't be able to hover parent)

    // The reference position stored in popup_pos will be used by Begin() to find a suitable position for the child menu,
    // However the final position is going to be different! It is chosen by FindBestWindowPosForPopup().
    // e.g. Menus tend to overlap each other horizontally to amplify relative Z-ordering.
    ImVec2 popup_pos, pos = window->DC.CursorPos;
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)
    {
        // Menu inside an horizontal menu bar
        // Selectable extend their highlight by half ItemSpacing in each direction.
        // For ChildMenu, the popup position will be overwritten by the call to FindBestWindowPosForPopup() in Begin()
        popup_pos = ImVec2(pos.x - 1.0f - IM_FLOOR(style.ItemSpacing.x * 0.5f), pos.y - style.FramePadding.y + window->MenuBarHeight());
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * 0.5f);
        PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x * 2.0f, style.ItemSpacing.y));
        float w = label_size.x;
        pressed = Selectable(label, menu_is_open, ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(w, 0.0f));
        PopStyleVar();
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * (-1.0f + 0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().
    }
    else
    {
        // Menu inside a menu
        // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.
        //  Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.
        popup_pos = ImVec2(pos.x, pos.y - style.WindowPadding.y);
        float min_w = window->DC.MenuColumns.DeclColumns(label_size.x, 0.0f, IM_FLOOR(g.FontSize * 1.20f)); // Feedback to next frame
        float extra_w = ImMax(0.0f, GetContentRegionAvail().x - min_w);
        pressed = Selectable(label, menu_is_open, ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups | ImGuiSelectableFlags_SpanAvailWidth | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(min_w, 0.0f));
        ImU32 text_col = GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled);
        RenderArrow(window->DrawList, pos + ImVec2(window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.30f, 0.0f), text_col, ImGuiDir_Right);
    }

    const bool hovered = enabled && ItemHoverable(window->DC.LastItemRect, id);
    if (menuset_is_open)
        g.NavWindow = backed_nav_window;

    bool want_open = false;
    bool want_close = false;
    if (window->DC.LayoutType == ImGuiLayoutType_Vertical) // (window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu))
    {
        // Close menu when not hovering it anymore unless we are moving roughly in the direction of the menu
        // Implement http://bjk5.com/post/44698559168/breaking-down-amazons-mega-dropdown to avoid using timers, so menus feels more reactive.
        bool moving_toward_other_child_menu = false;

        ImGuiWindow* child_menu_window = (g.BeginPopupStack.Size < g.OpenPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].SourceWindow == window) ? g.OpenPopupStack[g.BeginPopupStack.Size].Window : NULL;
        if (g.HoveredWindow == window && child_menu_window != NULL && !(window->Flags & ImGuiWindowFlags_MenuBar))
        {
            // FIXME-DPI: Values should be derived from a master "scale" factor.
            ImRect next_window_rect = child_menu_window->Rect();
            ImVec2 ta = g.IO.MousePos - g.IO.MouseDelta;
            ImVec2 tb = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetTL() : next_window_rect.GetTR();
            ImVec2 tc = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetBL() : next_window_rect.GetBR();
            float extra = ImClamp(ImFabs(ta.x - tb.x) * 0.30f, 5.0f, 30.0f);    // add a bit of extra slack.
            ta.x += (window->Pos.x < child_menu_window->Pos.x) ? -0.5f : +0.5f; // to avoid numerical issues
            tb.y = ta.y + ImMax((tb.y - extra) - ta.y, -100.0f);                // triangle is maximum 200 high to limit the slope and the bias toward large sub-menus // FIXME: Multiply by fb_scale?
            tc.y = ta.y + ImMin((tc.y + extra) - ta.y, +100.0f);
            moving_toward_other_child_menu = ImTriangleContainsPoint(ta, tb, tc, g.IO.MousePos);
            //GetForegroundDrawList()->AddTriangleFilled(ta, tb, tc, moving_within_opened_triangle ? IM_COL32(0,128,0,128) : IM_COL32(128,0,0,128)); // [DEBUG]
        }
        if (menu_is_open && !hovered && g.HoveredWindow == window && g.HoveredIdPreviousFrame != 0 && g.HoveredIdPreviousFrame != id && !moving_toward_other_child_menu)
            want_close = true;

        if (!menu_is_open && hovered && pressed) // Click to open
            want_open = true;
        else if (!menu_is_open && hovered && !moving_toward_other_child_menu) // Hover to open
            want_open = true;

        if (g.NavActivateId == id)
        {
            want_close = menu_is_open;
            want_open = !menu_is_open;
        }
        if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Right) // Nav-Right to open
        {
            want_open = true;
            NavMoveRequestCancel();
        }
    }
    else
    {
        // Menu bar
        if (menu_is_open && pressed && menuset_is_open) // Click an open menu again to close it
        {
            want_close = true;
            want_open = menu_is_open = false;
        }
        else if (pressed || (hovered && menuset_is_open && !menu_is_open)) // First click to open, then hover to open others
        {
            want_open = true;
        }
        else if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Down) // Nav-Down to open
        {
            want_open = true;
            NavMoveRequestCancel();
        }
    }

    if (!enabled) // explicitly close if an open menu becomes disabled, facilitate users code a lot in pattern such as 'if (BeginMenu("options", has_object)) { ..use object.. }'
        want_close = true;
    if (want_close && IsPopupOpen(id, ImGuiPopupFlags_None))
        ClosePopupToLevel(g.BeginPopupStack.Size, true);

    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.ItemFlags | ImGuiItemStatusFlags_Openable | (menu_is_open ? ImGuiItemStatusFlags_Opened : 0));

    if (!menu_is_open && want_open && g.OpenPopupStack.Size > g.BeginPopupStack.Size)
    {
        // Don't recycle same menu level in the same frame, first close the other menu and yield for a frame.
        OpenPopup(label);
        return false;
    }

    menu_is_open |= want_open;
    if (want_open)
        OpenPopup(label);

    if (menu_is_open)
    {
        SetNextWindowPos(popup_pos, ImGuiCond_Always);
        menu_is_open = BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
    }
    else
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
    }

    return menu_is_open;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x58da6(%rip), %rax     # 0xfbcd0
movq (%rax), %r14
movq 0x1ae0(%r14), %r13
movb $0x1, 0x90(%r13)
cmpb $0x0, 0x93(%r13)
jne 0xa357e
movq %rdi, %r15
movl %esi, -0x34(%rbp)
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4570a
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x47824
xorl %esi, %esi
testb $0x14, 0xf(%r13)
setne %sil
shll $0x18, %esi
orl $0x10080145, %esi       # imm = 0x10080145
movq 0x30c8(%r14), %r12
movslq 0x30c0(%r14), %r8
leaq (%r12,%r8,4), %rcx
movq %r12, %rdx
cmpq %rcx, %rdx
jae 0xa2fc1
leaq 0x4(%rdx), %rdi
cmpl %ebx, (%rdx)
movq %rdi, %rdx
jne 0xa2f91
testb %al, %al
je 0xa3573
movl %ebx, %edi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x57298
cmpl 0x30c4(%r14), %r8d
movl %eax, -0x2c(%rbp)
movq %r15, -0x40(%rbp)
movl %esi, -0x6c(%rbp)
jne 0xa304c
leal 0x1(%r8), %r15d
testl %r8d, %r8d
je 0xa2fed
movl %r8d, %ecx
shrl $0x1f, %ecx
addl %r8d, %ecx
sarl %ecx
addl %r8d, %ecx
jmp 0xa2ff2
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
movslq %r15d, %rdi
shlq $0x2, %rdi
callq 0x41c63
movq %rax, %r12
movq 0x30c8(%r14), %rsi
testq %rsi, %rsi
je 0xa3033
movslq 0x30c0(%r14), %rdx
shlq $0x2, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x30c8(%r14), %rdi
callq 0x41d3c
movq %r12, 0x30c8(%r14)
movl %r15d, 0x30c4(%r14)
movslq 0x30c0(%r14), %r8
movq -0x40(%rbp), %r15
movl %ebx, (%r12,%r8,4)
incl 0x30c0(%r14)
movss 0x11f71(%rip), %xmm0    # 0xb4fd0
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x44a23
testb $0x4, 0xf(%r13)
jne 0xa30dd
movl 0x1c80(%r14), %eax
cmpl %eax, 0x1c70(%r14)
jle 0xa30dd
testl %eax, %eax
movl -0x2c(%rbp), %esi
js 0xa370a
movslq 0xc8(%r13), %rcx
testq %rcx, %rcx
jle 0xa3729
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x1c78(%r14), %rdx
movq 0x1c90(%r14), %rdi
movq %rdi, -0x78(%rbp)
movl 0x1c(%rdx,%rax), %eax
movq 0xd0(%r13), %rdx
leaq 0x1c90(%r14), %rdi
cmpl -0x4(%rdx,%rcx,4), %eax
jne 0xa34cb
movq %r13, (%rdi)
movb $0x1, %al
jmp 0xa30f4
leaq 0x1c90(%r14), %rdi
movq 0x1c90(%r14), %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
movl -0x2c(%rbp), %esi
movq %rdi, -0x98(%rbp)
movl %eax, -0x4c(%rbp)
movl 0xd8(%r13), %eax
movss 0xdc(%r13), %xmm2
movd %eax, %xmm1
cmpl $0x0, 0x1bc(%r13)
movzbl %sil, %ecx
movl %ecx, -0x30(%rbp)
je 0xa3236
movd %xmm1, -0x38(%rbp)
movaps %xmm2, %xmm1
subss 0x1568(%r14), %xmm1
movl %eax, -0x68(%rbp)
movss %xmm1, -0x64(%rbp)
leaq 0x168(%r13), %rdi
movss 0x1980(%r14), %xmm1
mulss 0x2dc40(%rip), %xmm1    # 0xd0d98
cvttps2dq %xmm1, %xmm1
movaps %xmm2, -0x90(%rbp)
cvtdq2ps %xmm1, %xmm2
xorps %xmm1, %xmm1
callq 0xa2948
movss %xmm0, -0x60(%rbp)
callq 0x51f24
movss -0x60(%rbp), %xmm2
subss %xmm2, %xmm0
movaps %xmm0, %xmm1
cmpless 0x126b7(%rip), %xmm1    # 0xb5844
andnps %xmm0, %xmm1
movaps %xmm1, -0xb0(%rbp)
movl -0x34(%rbp), %r15d
movl %r15d, %eax
xorb $0x1, %al
movzbl %al, %r12d
leal 0xb00001(,%r12,8), %edx
leaq -0x48(%rbp), %rcx
movss %xmm2, (%rcx)
movl $0x0, 0x4(%rcx)
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x94650
movb %al, -0x60(%rbp)
movss 0x11e12(%rip), %xmm0    # 0xb4fe4
movl %r12d, %edi
callq 0x43bca
movaps -0xb0(%rbp), %xmm1
addss 0x17c(%r13), %xmm1
movq 0x2b8(%r13), %rdi
movss 0x1980(%r14), %xmm0
mulss 0x126ea(%rip), %xmm0    # 0xb58ec
addss %xmm1, %xmm0
addss -0x38(%rbp), %xmm0
movaps -0x90(%rbp), %xmm1
addss 0x1262a(%rip), %xmm1    # 0xb5844
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movl %eax, %esi
movl $0x1, %edx
movss 0x11db8(%rip), %xmm1    # 0xb4fe4
callq 0x81dcb
jmp 0xa335f
addss 0x11d92(%rip), %xmm1    # 0xb4fd0
movss 0x11dbe(%rip), %xmm3    # 0xb5004
movaps %xmm1, %xmm4
movss 0x15a8(%r14), %xmm1
mulss %xmm3, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
subss %xmm1, %xmm4
movss %xmm4, -0x38(%rbp)
subss 0x159c(%r14), %xmm2
movaps %xmm2, -0x90(%rbp)
movq %r13, %rdi
movaps %xmm0, -0x60(%rbp)
callq 0x5e2b4
addss -0x90(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
movss %xmm1, -0x68(%rbp)
movss %xmm0, -0x64(%rbp)
movss 0x15a8(%r14), %xmm0
movss 0x11d5a(%rip), %xmm1    # 0xb5004
mulss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
addss 0xd8(%r13), %xmm1
movss %xmm1, 0xd8(%r13)
addss %xmm0, %xmm0
movss 0x15ac(%r14), %xmm1
leaq -0x48(%rbp), %r12
movss %xmm0, (%r12)
movss %xmm1, 0x4(%r12)
movl $0xd, %edi
movq %r12, %rsi
callq 0x4417f
movl -0x34(%rbp), %r15d
movl %r15d, %eax
xorb $0x1, %al
movzbl %al, %eax
leal 0x300001(,%rax,8), %edx
movaps -0x60(%rbp), %xmm0
movss %xmm0, (%r12)
movl $0x0, 0x4(%r12)
leaq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x94650
movb %al, -0x60(%rbp)
movl $0x1, %edi
callq 0x44325
movss 0x15a8(%r14), %xmm0
mulss 0x1257e(%rip), %xmm0    # 0xb58c4
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
addss 0xd8(%r13), %xmm0
movss %xmm0, 0xd8(%r13)
testb %r15b, %r15b
je 0xa337a
leaq 0x12c(%r13), %rdi
movl %ebx, %esi
callq 0x4632f
movl -0x34(%rbp), %edi
movl %eax, %r12d
jmp 0xa3380
movl %r15d, %edi
xorl %r12d, %r12d
movl -0x2c(%rbp), %r8d
movl -0x4c(%rbp), %r15d
testb %r15b, %r15b
je 0xa339b
movq -0x78(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rax, (%rcx)
cmpl $0x1, 0x1bc(%r13)
jne 0xa3464
movl 0x1c80(%r14), %eax
cmpl 0x1c70(%r14), %eax
jge 0xa33db
testl %eax, %eax
js 0xa370a
movq 0x1c78(%r14), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
cmpq %r13, 0x10(%rcx,%rdx)
je 0xa35b0
leaq 0x1ae8(%r14), %r15
movb $0x1, %al
movl %r8d, %ecx
xorb $0x1, %cl
movl %r12d, %edx
orb %cl, %dl
jne 0xa33fa
cmpq %r13, (%r15)
je 0xa3594
xorl %edx, %edx
movl -0x30(%rbp), %r9d
movb -0x60(%rbp), %r10b
movl %r10d, %esi
andb %cl, %sil
andb %r12b, %sil
movzbl %sil, %esi
movzbl %al, %eax
testb %r12b, %r12b
cmovel %esi, %eax
testb %r8b, %r8b
cmovnel %esi, %eax
testb %r10b, %r10b
cmovnel %esi, %eax
cmpl %ebx, 0x1ca0(%r14)
movzbl %cl, %r12d
cmovnel %eax, %r12d
movzbl %dl, %r15d
cmovel %r9d, %r15d
cmpl %ebx, 0x1c98(%r14)
jne 0xa34d8
cmpb $0x1, 0x1d00(%r14)
jne 0xa34d8
cmpl $0x1, 0x1d10(%r14)
je 0xa34b2
jmp 0xa34d8
movb -0x60(%rbp), %al
testb %al, %al
je 0xa347d
andb %r8b, %al
andb %al, %r15b
xorb %r15b, %r8b
movl %r15d, %r12d
xorb $0x1, %r12b
jmp 0xa34d8
andb %r12b, %r15b
xorb $0x1, %r15b
movl %r8d, %eax
orb %r15b, %al
cmpb $0x1, %al
jne 0xa34c3
cmpl %ebx, 0x1c98(%r14)
jne 0xa34d2
cmpb $0x1, 0x1d00(%r14)
jne 0xa34d2
xorl %r15d, %r15d
cmpl $0x3, 0x1d10(%r14)
jne 0xa3648
callq 0x57daa
movl -0x34(%rbp), %edi
movl -0x2c(%rbp), %r8d
movb $0x1, %r12b
jmp 0xa34d8
movb $0x1, %r12b
xorl %r8d, %r8d
jmp 0xa34d5
xorl %eax, %eax
jmp 0xa30f4
xorl %r12d, %r12d
xorl %r15d, %r15d
testb %dil, %dil
je 0xa34e2
testb %r15b, %r15b
je 0xa3509
movl %ebx, %edi
xorl %esi, %esi
movl %r8d, %r15d
callq 0x47824
movl %r15d, %r8d
testb %al, %al
je 0xa3509
movl 0x1c80(%r14), %edi
movl $0x1, %esi
callq 0x5702e
movl %r15d, %r8d
movl %r12d, %eax
notb %al
orb %r8b, %al
testb $0x1, %al
jne 0xa3534
movl 0x1c70(%r14), %eax
cmpl 0x1c80(%r14), %eax
jle 0xa3534
xorl %ebx, %ebx
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x56c96
jmp 0xa3580
testb $0x1, %r12b
movq -0x40(%rbp), %rdi
je 0xa3547
xorl %esi, %esi
callq 0x56c96
jmp 0xa354c
testb %r8b, %r8b
je 0xa3573
leaq -0x48(%rbp), %rdx
movq $0x0, (%rdx)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x545cf
movl %ebx, %edi
movl -0x6c(%rbp), %esi
callq 0x57298
movl %eax, %ebx
jmp 0xa3580
movl $0x0, 0x1b88(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x1b20(%r14), %edx
testl %edx, %edx
setne %sil
cmpl %ebx, %edx
setne %dl
andb %sil, %dl
andb %al, %dl
jmp 0xa33fc
leaq 0x1ae8(%r14), %r15
movb $0x1, %al
cmpq %r13, 0x1ae8(%r14)
jne 0xa33e4
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0xa33e4
testb $0x4, 0xd(%r13)
jne 0xa33e4
movss 0x10(%rcx), %xmm0
movss 0x14(%rcx), %xmm5
movss 0x18(%rcx), %xmm3
movss 0x1c(%rcx), %xmm4
addss %xmm5, %xmm4
leaq 0x128(%r14), %rcx
movss 0x128(%r14), %xmm2
movss 0x12c(%r14), %xmm1
subss 0x3b8(%r14), %xmm2
subss 0x3bc(%r14), %xmm1
movaps %xmm2, %xmm6
unpcklps %xmm1, %xmm6            # xmm6 = xmm6[0],xmm1[0],xmm6[1],xmm1[1]
movlps %xmm6, -0x48(%rbp)
ucomiss 0x10(%r13), %xmm0
jbe 0xa3650
movaps %xmm0, %xmm3
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movss 0x1227e(%rip), %xmm4    # 0xb58c4
jmp 0xa3665
xorl %r12d, %r12d
jmp 0xa34d8
addss %xmm3, %xmm0
movaps %xmm0, %xmm3
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movss 0x1199f(%rip), %xmm4    # 0xb5004
leaq -0xc0(%rbp), %rsi
movlps %xmm3, (%rsi)
leaq -0xb8(%rbp), %rdx
movlps %xmm0, (%rdx)
addss %xmm2, %xmm4
subss %xmm3, %xmm2
andps 0x12148(%rip), %xmm2    # 0xb57d0
mulss 0x1225c(%rip), %xmm2    # 0xb58ec
movss 0x1783c(%rip), %xmm5    # 0xbaed4
minss %xmm2, %xmm5
movss 0x121f0(%rip), %xmm6    # 0xb5894
cmpltss %xmm6, %xmm2
movaps %xmm2, %xmm7
andnps %xmm5, %xmm7
andps %xmm6, %xmm2
orps %xmm7, %xmm2
leaq -0x48(%rbp), %rdi
movss %xmm4, (%rdi)
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
subss %xmm2, %xmm3
subss %xmm1, %xmm3
maxss 0x17857(%rip), %xmm3    # 0xbaf28
addss %xmm1, %xmm3
movss %xmm3, 0x4(%rsi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss %xmm2, %xmm0
subss %xmm1, %xmm0
minss 0x12196(%rip), %xmm0    # 0xb5884
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rdx)
callq 0x41776
xorb $0x1, %al
movl -0x2c(%rbp), %r8d
movl -0x34(%rbp), %edi
jmp 0xa33e4
leaq 0x15f67(%rip), %rdi     # 0xb9678
leaq 0x15f73(%rip), %rsi     # 0xb968b
leaq 0x1742b(%rip), %rcx     # 0xbab4a
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
leaq 0x2a27a(%rip), %rdi     # 0xcd9aa
leaq 0x15f54(%rip), %rsi     # 0xb968b
leaq 0x172ba(%rip), %rcx     # 0xba9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140