// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::NewFrame()
void ImGui::NewFrame()
{
    ImGuiState& g = *GImGui;

    // Check user data
    IM_ASSERT(g.IO.DeltaTime >= 0.0f);
    IM_ASSERT(g.IO.DisplaySize.x >= 0.0f && g.IO.DisplaySize.y >= 0.0f);
    IM_ASSERT(g.IO.Fonts->Fonts.Size > 0);           // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
    IM_ASSERT(g.IO.Fonts->Fonts[0]->IsLoaded());     // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
    IM_ASSERT(g.Style.CurveTessellationTol > 0.0f);  // Invalid

    if (!g.Initialized)
    {
        // Initialize on first frame
        g.LogClipboard = (ImGuiTextBuffer*)ImGui::MemAlloc(sizeof(ImGuiTextBuffer));
        new(g.LogClipboard) ImGuiTextBuffer();

        IM_ASSERT(g.Settings.empty());
        LoadSettings();
        g.Initialized = true;
    }

    SetCurrentFont(g.IO.Fonts->Fonts[0]);

    g.Time += g.IO.DeltaTime;
    g.FrameCount += 1;
    g.Tooltip[0] = '\0';
    g.OverlayDrawList.Clear();
    g.OverlayDrawList.PushTextureID(g.IO.Fonts->TexID);
    g.OverlayDrawList.PushClipRectFullScreen();
    g.OverlayDrawList.AddDrawCmd();

    // Mark rendering data as invalid to prevent user who may have a handle on it to use it
    g.RenderDrawData.Valid = false;
    g.RenderDrawData.CmdLists = NULL;
    g.RenderDrawData.CmdListsCount = g.RenderDrawData.TotalVtxCount = g.RenderDrawData.TotalIdxCount = 0;

    // Update inputs state
    if (g.IO.MousePos.x < 0 && g.IO.MousePos.y < 0)
        g.IO.MousePos = ImVec2(-9999.0f, -9999.0f);
    if ((g.IO.MousePos.x < 0 && g.IO.MousePos.y < 0) || (g.IO.MousePosPrev.x < 0 && g.IO.MousePosPrev.y < 0))   // if mouse just appeared or disappeared (negative coordinate) we cancel out movement in MouseDelta
        g.IO.MouseDelta = ImVec2(0.0f, 0.0f);
    else
        g.IO.MouseDelta = g.IO.MousePos - g.IO.MousePosPrev;
    g.IO.MousePosPrev = g.IO.MousePos;
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
    {
        g.IO.MouseDownDurationPrev[i] = g.IO.MouseDownDuration[i];
        g.IO.MouseDownDuration[i] = g.IO.MouseDown[i] ? (g.IO.MouseDownDuration[i] < 0.0f ? 0.0f : g.IO.MouseDownDuration[i] + g.IO.DeltaTime) : -1.0f;
        g.IO.MouseClicked[i] = g.IO.MouseDownDuration[i] == 0.0f;
        g.IO.MouseReleased[i] = g.IO.MouseDownDurationPrev[i] >= 0.0f && !g.IO.MouseDown[i];
        g.IO.MouseDoubleClicked[i] = false;
        if (g.IO.MouseClicked[i])
        {
            if (g.Time - g.IO.MouseClickedTime[i] < g.IO.MouseDoubleClickTime)
            {
                if (ImLengthSqr(g.IO.MousePos - g.IO.MouseClickedPos[i]) < g.IO.MouseDoubleClickMaxDist * g.IO.MouseDoubleClickMaxDist)
                    g.IO.MouseDoubleClicked[i] = true;
                g.IO.MouseClickedTime[i] = -FLT_MAX;    // so the third click isn't turned into a double-click
            }
            else
            {
                g.IO.MouseClickedTime[i] = g.Time;
            }
            g.IO.MouseClickedPos[i] = g.IO.MousePos;
            g.IO.MouseDragMaxDistanceSqr[i] = 0.0f;
        }
        else if (g.IO.MouseDown[i])
        {
            g.IO.MouseDragMaxDistanceSqr[i] = ImMax(g.IO.MouseDragMaxDistanceSqr[i], ImLengthSqr(g.IO.MousePos - g.IO.MouseClickedPos[i]));
        }
    }
    memcpy(g.IO.KeysDownDurationPrev, g.IO.KeysDownDuration, sizeof(g.IO.KeysDownDuration));
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.KeysDown); i++)
        g.IO.KeysDownDuration[i] = g.IO.KeysDown[i] ? (g.IO.KeysDownDuration[i] < 0.0f ? 0.0f : g.IO.KeysDownDuration[i] + g.IO.DeltaTime) : -1.0f;

    // Calculate frame-rate for the user, as a purely luxurious feature
    g.FramerateSecPerFrameAccum += g.IO.DeltaTime - g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx];
    g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx] = g.IO.DeltaTime;
    g.FramerateSecPerFrameIdx = (g.FramerateSecPerFrameIdx + 1) % IM_ARRAYSIZE(g.FramerateSecPerFrame);
    g.IO.Framerate = 1.0f / (g.FramerateSecPerFrameAccum / (float)IM_ARRAYSIZE(g.FramerateSecPerFrame));

    // Clear reference to active widget if the widget isn't alive anymore
    g.HoveredIdPreviousFrame = g.HoveredId;
    g.HoveredId = 0;
    if (!g.ActiveIdIsAlive && g.ActiveIdPreviousFrame == g.ActiveId && g.ActiveId != 0)
        SetActiveID(0);
    g.ActiveIdPreviousFrame = g.ActiveId;
    g.ActiveIdIsAlive = false;
    g.ActiveIdIsJustActivated = false;
    if (!g.ActiveId)
        g.MovedWindow = NULL;

    // Delay saving settings so we don't spam disk too much
    if (g.SettingsDirtyTimer > 0.0f)
    {
        g.SettingsDirtyTimer -= g.IO.DeltaTime;
        if (g.SettingsDirtyTimer <= 0.0f)
            SaveSettings();
    }

    // Find the window we are hovering. Child windows can extend beyond the limit of their parent so we need to derive HoveredRootWindow from HoveredWindow
    g.HoveredWindow = FindHoveredWindow(g.IO.MousePos, false);
    if (g.HoveredWindow && (g.HoveredWindow->Flags & ImGuiWindowFlags_ChildWindow))
        g.HoveredRootWindow = g.HoveredWindow->RootWindow;
    else
        g.HoveredRootWindow = FindHoveredWindow(g.IO.MousePos, true);

    if (ImGuiWindow* modal_window = GetFrontMostModalRootWindow())
    {
        g.ModalWindowDarkeningRatio = ImMin(g.ModalWindowDarkeningRatio + g.IO.DeltaTime * 6.0f, 1.0f);
        if (g.HoveredRootWindow != modal_window)
            g.HoveredRootWindow = g.HoveredWindow = NULL;
    }
    else
    {
        g.ModalWindowDarkeningRatio = 0.0f;
    }

    // Are we using inputs? Tell user so they can capture/discard the inputs away from the rest of their application.
    // When clicking outside of a window we assume the click is owned by the application and won't request capture.
    int mouse_earliest_button_down = -1;
    bool mouse_any_down = false;
    for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
    {
        if (g.IO.MouseClicked[i])
            g.IO.MouseDownOwned[i] = (g.HoveredWindow != NULL) || (!g.OpenedPopupStack.empty());
        mouse_any_down |= g.IO.MouseDown[i];
        if (g.IO.MouseDown[i])
            if (mouse_earliest_button_down == -1 || g.IO.MouseClickedTime[mouse_earliest_button_down] > g.IO.MouseClickedTime[i])
                mouse_earliest_button_down = i;
    }
    bool mouse_owned_by_application = mouse_earliest_button_down != -1 && !g.IO.MouseDownOwned[mouse_earliest_button_down];
    g.IO.WantCaptureMouse = (!mouse_owned_by_application && g.HoveredWindow != NULL) || (!mouse_owned_by_application && mouse_any_down) || (g.ActiveId != 0) || (!g.OpenedPopupStack.empty()) || (g.CaptureMouseNextFrame);
    g.IO.WantCaptureKeyboard = (g.ActiveId != 0) || (g.CaptureKeyboardNextFrame);
    g.IO.WantTextInput = (g.ActiveId != 0 && g.InputTextState.Id == g.ActiveId);
    g.MouseCursor = ImGuiMouseCursor_Arrow;
    g.CaptureMouseNextFrame = g.CaptureKeyboardNextFrame = false;

    // If mouse was first clicked outside of ImGui bounds we also cancel out hovering.
    if (mouse_owned_by_application)
        g.HoveredWindow = g.HoveredRootWindow = NULL;

    // Scale & Scrolling
    if (g.HoveredWindow && g.IO.MouseWheel != 0.0f && !g.HoveredWindow->Collapsed)
    {
        ImGuiWindow* window = g.HoveredWindow;
        if (g.IO.KeyCtrl)
        {
            if (g.IO.FontAllowUserScaling)
            {
                // Zoom / Scale window
                float new_font_scale = ImClamp(window->FontWindowScale + g.IO.MouseWheel * 0.10f, 0.50f, 2.50f);
                float scale = new_font_scale / window->FontWindowScale;
                window->FontWindowScale = new_font_scale;

                const ImVec2 offset = window->Size * (1.0f - scale) * (g.IO.MousePos - window->Pos) / window->Size;
                window->Pos += offset;
                window->PosFloat += offset;
                window->Size *= scale;
                window->SizeFull *= scale;
            }
        }
        else
        {
            // Scroll
            if (!(window->Flags & ImGuiWindowFlags_NoScrollWithMouse))
            {
                const int scroll_lines = (window->Flags & ImGuiWindowFlags_ComboBox) ? 3 : 5;
                SetWindowScrollY(window, window->Scroll.y - g.IO.MouseWheel * window->CalcFontSize() * scroll_lines);
            }
        }
    }

    // Pressing TAB activate widget focus
    // NB: Don't discard FocusedWindow if it isn't active, so that a window that go on/off programatically won't lose its keyboard focus.
    if (g.ActiveId == 0 && g.FocusedWindow != NULL && g.FocusedWindow->Active && IsKeyPressedMap(ImGuiKey_Tab, false))
        g.FocusedWindow->FocusIdxTabRequestNext = 0;

    // Mark all windows as not visible
    for (int i = 0; i != g.Windows.Size; i++)
    {
        ImGuiWindow* window = g.Windows[i];
        window->WasActive = window->Active;
        window->Active = false;
        window->Accessed = false;
    }

    // No window should be open at the beginning of the frame.
    // But in order to allow the user to call NewFrame() multiple times without calling Render(), we are doing an explicit clear.
    g.CurrentWindowStack.resize(0);
    g.CurrentPopupStack.resize(0);
    CloseInactivePopups();

    // Create implicit window - we will only render it if the user has added something to it.
    ImGui::SetNextWindowSize(ImVec2(400,400), ImGuiSetCond_FirstUseEver);
    ImGui::Begin("Debug");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x4a332(%rip), %r12     # 0x55480
movss 0x10(%r12), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0xbfc9
movss 0x8(%r12), %xmm1
ucomiss %xmm0, %xmm1
jb 0xbf8b
movss 0xc(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xbf8b
movq 0x90(%r12), %rax
cmpl $0x0, 0x30(%rax)
jle 0xbfe8
movq 0x38(%rax), %rcx
movq (%rcx), %rcx
cmpq $0x0, 0x30(%rcx)
je 0xc007
movss 0x145c(%r12), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc026
cmpb $0x0, (%r12)
jne 0xb3de
incl 0x334(%r12)
movl $0x10, %edi
callq *0xd0(%r12)
movq %rax, 0x2bf8(%r12)
movq %rax, %rdi
callq 0x244a8
cmpl $0x0, 0x17b0(%r12)
jne 0xc045
movq 0x4a27f(%rip), %rax     # 0x55480
movq %rax, -0x60(%rbp)
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xb3c7
leaq 0x33885(%rip), %rsi     # 0x3ea9e
leaq -0x34(%rbp), %rdx
movl $0x1, %ecx
callq 0x8ed8
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0xb3c7
movslq -0x34(%rbp), %rax
testq %rax, %rax
jle 0xb3b0
movq -0x58(%rbp), %r15
movq %r15, %r13
addq %rax, %r13
leaq -0x2c(%rbp), %r14
xorl %eax, %eax
movq %r15, %rbx
movzbl (%rbx), %ecx
cmpl $0xa, %ecx
je 0xb269
cmpl $0xd, %ecx
je 0xb269
incq %rbx
cmpq %r13, %rbx
jb 0xb254
cmpq %r15, %rbx
jbe 0xb2c3
cmpb $0x5b, (%r15)
jne 0xb2c3
cmpb $0x5d, -0x1(%rbx)
jne 0xb2c3
movl %ebx, %ecx
subl %r15d, %ecx
addl $-0x2, %ecx
incq %r15
leaq -0xa0(%rbp), %rdi
movl $0x40, %esi
leaq 0x33973(%rip), %rdx     # 0x3ec0b
movq %r15, %r8
movq %rdi, %r15
xorl %eax, %eax
callq 0x8678
movq %r15, %rdi
callq 0x23255
testq %rax, %rax
jne 0xb3a1
movq %r15, %rdi
callq 0x232d8
jmp 0xb3a1
testq %rax, %rax
je 0xb304
movq %rax, -0x50(%rbp)
movq %r15, %rdi
leaq 0x337cb(%rip), %rsi     # 0x3eaa1
movq %r14, %rcx
leaq -0xa0(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xb30b
movl -0xa0(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %edx, 0xc(%rax)
movl %ecx, 0x10(%rax)
jmp 0xb3a1
xorl %eax, %eax
jmp 0xb3a1
movq %r15, %rdi
leaq 0x33796(%rip), %rsi     # 0x3eaab
leaq -0xa0(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xb37b
movss -0xa0(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movq -0x60(%rbp), %rax
movss 0x13f4(%rax), %xmm2
movss 0x13f8(%rax), %xmm3
movaps %xmm2, %xmm4
cmpless %xmm0, %xmm4
andps %xmm4, %xmm0
andnps %xmm2, %xmm4
orps %xmm0, %xmm4
movaps %xmm3, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm3, %xmm0
orps %xmm1, %xmm0
unpcklps %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
movq -0x50(%rbp), %rax
movlps %xmm4, 0x14(%rax)
jmp 0xb3a1
movq %r15, %rdi
leaq 0x33731(%rip), %rsi     # 0x3eab6
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x1, %eax
movq -0x50(%rbp), %rax
jne 0xb3a1
cmpl $0x0, -0x30(%rbp)
setne 0x1c(%rax)
incq %rbx
movq %rbx, %r15
cmpq %r13, %rbx
jb 0xb254
movq 0x4a0c9(%rip), %rax     # 0x55480
decl 0x334(%rax)
movq -0x58(%rbp), %rdi
callq *0xd8(%rax)
movb $0x1, (%r12)
movq 0x90(%r12), %rax
cmpl $0x0, 0x30(%rax)
jle 0xc064
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0xc07e
movss 0x10(%r12), %xmm0
addss 0x1728(%r12), %xmm0
movss %xmm0, 0x1728(%r12)
incl 0x172c(%r12)
xorl %r14d, %r14d
movb %r14b, 0x27e0(%r12)
leaq 0x18a8(%r12), %rbx
movq %rbx, %rdi
callq 0x2c8b0
movq 0x90(%r12), %rsi
movq %rbx, %rdi
callq 0x2d11e
movq %rbx, %rdi
callq 0x2d040
movq %rbx, %rdi
callq 0x2cc3e
movb %r14b, 0x1850(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x1858(%r12)
movl $0x0, 0x1868(%r12)
movss 0xf0(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xb4a1
ucomiss 0xf4(%r12), %xmm1
jbe 0xb4a1
movabsq $-0x39e3c3ff39e3c400, %rax # imm = 0xC61C3C00C61C3C00
movq %rax, 0xf0(%r12)
movss 0x31f19(%rip), %xmm0    # 0x3d3b8
jmp 0xb4a6
ucomiss %xmm0, %xmm1
jbe 0xb4b1
ucomiss 0xf4(%r12), %xmm1
ja 0xb4d2
movss 0x344(%r12), %xmm2
movss 0x348(%r12), %xmm1
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jbe 0xb4e0
ucomiss %xmm1, %xmm3
jbe 0xb4e0
movq $0x0, 0x34c(%r12)
jmp 0xb4fe
movss 0xf4(%r12), %xmm3
subss %xmm2, %xmm0
subss %xmm1, %xmm3
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movlps %xmm0, 0x34c(%r12)
movq 0xf0(%r12), %rax
movq %rax, 0x344(%r12)
movq %rax, %rcx
shrq $0x20, %rcx
movd %ecx, %xmm0
movd %eax, %xmm1
xorl %ecx, %ecx
movss 0x31e75(%rip), %xmm2    # 0x3d39c
xorps %xmm3, %xmm3
movss 0x31e8a(%rip), %xmm4    # 0x3d3bc
xorl %edx, %edx
movss 0x3a8(%r12,%rdx,4), %xmm5
movss %xmm5, 0x3bc(%r12,%rdx,4)
movb 0xf8(%r12,%rdx), %sil
movaps %xmm2, %xmm6
cmpb $0x1, %sil
jne 0xb56c
xorps %xmm6, %xmm6
ucomiss %xmm5, %xmm6
ja 0xb56c
movss 0x10(%r12), %xmm6
addss %xmm5, %xmm6
ucomiss %xmm3, %xmm6
setnp %dil
sete %r8b
andb %dil, %r8b
movl %esi, %edi
xorb $0x1, %dil
ucomiss %xmm3, %xmm5
movzbl %dil, %edi
cmovbl %ecx, %edi
ucomiss %xmm3, %xmm6
movss %xmm6, 0x3a8(%r12,%rdx,4)
movb %r8b, 0x354(%r12,%rdx)
movb %dil, 0x39d(%r12,%rdx)
movb $0x0, 0x398(%r12,%rdx)
jne 0xb646
jp 0xb646
movss 0x1728(%r12), %xmm5
movaps %xmm5, %xmm6
subss 0x384(%r12,%rdx,4), %xmm6
movss 0x28(%r12), %xmm7
ucomiss %xmm6, %xmm7
jbe 0xb626
movdqa %xmm1, %xmm5
subss 0x35c(%r12,%rdx,8), %xmm5
movdqa %xmm0, %xmm6
subss 0x360(%r12,%rdx,8), %xmm6
mulss %xmm6, %xmm6
mulss %xmm5, %xmm5
addss %xmm6, %xmm5
movss 0x2c(%r12), %xmm6
mulss %xmm6, %xmm6
ucomiss %xmm5, %xmm6
movaps %xmm4, %xmm5
jbe 0xb626
movb $0x1, 0x398(%r12,%rdx)
movaps %xmm4, %xmm5
movss %xmm5, 0x384(%r12,%rdx,4)
movq %rax, 0x35c(%r12,%rdx,8)
movl $0x0, 0x3d0(%r12,%rdx,4)
jmp 0xb69e
testb %sil, %sil
je 0xb69e
movss 0x3d0(%r12,%rdx,4), %xmm5
movdqa %xmm1, %xmm6
subss 0x35c(%r12,%rdx,8), %xmm6
movdqa %xmm0, %xmm7
subss 0x360(%r12,%rdx,8), %xmm7
mulss %xmm7, %xmm7
mulss %xmm6, %xmm6
addss %xmm7, %xmm6
movaps %xmm6, %xmm7
cmpless %xmm5, %xmm7
movaps %xmm7, %xmm8
andnps %xmm6, %xmm8
andps %xmm5, %xmm7
orps %xmm8, %xmm7
movss %xmm7, 0x3d0(%r12,%rdx,4)
incq %rdx
cmpq $0x5, %rdx
jne 0xb534
leaq 0xbe4(%r12), %rdi
leaq 0x3e4(%r12), %rbx
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rsi
callq 0x7080
xorl %eax, %eax
movss 0x31cca(%rip), %xmm0    # 0x3d39c
cmpb $0x1, -0x2dc(%rbx,%rax)
movaps %xmm0, %xmm1
jne 0xb6f6
movss (%rbx,%rax,4), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm2, %xmm1
ja 0xb6f6
addss 0x10(%r12), %xmm2
movaps %xmm2, %xmm1
movss %xmm1, (%rbx,%rax,4)
incq %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0xb6d2
movss 0x10(%r12), %xmm0
movslq 0x2de8(%r12), %rax
movaps %xmm0, %xmm1
subss 0x2c08(%r12,%rax,4), %xmm1
addss 0x2dec(%r12), %xmm1
movss %xmm1, 0x2dec(%r12)
movss %xmm0, 0x2c08(%r12,%rax,4)
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %edx, %eax
incl %eax
movl %eax, %edx
shrl $0x1f, %edx
sarl $0x6, %eax
addl %edx, %eax
imull $0x78, %eax, %eax
subl %eax, %ecx
movl %ecx, 0x2de8(%r12)
movss 0x2dec(%r12), %xmm1
divss 0x31c42(%rip), %xmm1    # 0x3d3c0
movss 0x31c0a(%rip), %xmm2    # 0x3d390
divss %xmm1, %xmm2
movss %xmm2, 0x330(%r12)
movl 0x1788(%r12), %eax
movl %eax, 0x178c(%r12)
movl $0x0, 0x1788(%r12)
cmpb $0x0, 0x1798(%r12)
jne 0xb7fc
movl 0x1790(%r12), %eax
cmpl %eax, 0x1794(%r12)
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0xb7fc
movq 0x49ca2(%rip), %rax     # 0x55480
movl $0x0, 0x1790(%rax)
movw $0x1, 0x1799(%rax)
movq $0x0, 0x17a0(%rax)
movl 0x1790(%r12), %eax
movl %eax, 0x1794(%r12)
movw $0x0, 0x1798(%r12)
testl %eax, %eax
jne 0xb827
movq $0x0, 0x17a8(%r12)
movss 0x17c0(%r12), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jbe 0xb851
subss %xmm0, %xmm1
movss %xmm1, 0x17c0(%r12)
ucomiss %xmm1, %xmm2
jb 0xb851
callq 0xc12d
movsd 0xf0(%r12), %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %edi, %edi
callq 0xc32f
movq %rax, 0x1778(%r12)
testq %rax, %rax
je 0xb879
testb $0x10, 0xe(%rax)
jne 0xb889
movaps -0x50(%rbp), %xmm0
movl $0x1, %edi
callq 0xc32f
jmp 0xb890
movq 0x278(%rax), %rax
leaq 0x1778(%r12), %rbx
movq %rax, 0x1780(%r12)
callq 0xc3d3
testq %rax, %rax
je 0xb8e7
movss 0x10(%r12), %xmm0
mulss 0x31aeb(%rip), %xmm0    # 0x3d3a4
addss 0x18a0(%r12), %xmm0
minss 0x31ac5(%rip), %xmm0    # 0x3d390
movss %xmm0, 0x18a0(%r12)
cmpq %rax, 0x1780(%r12)
je 0xb8f3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xb8f3
movl $0x0, 0x18a0(%r12)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x1, 0x354(%r12,%rdx)
jne 0xb925
movb $0x1, %sil
cmpq $0x0, (%rbx)
jne 0xb91d
cmpl $0x0, 0x17f8(%r12)
setne %sil
movb %sil, 0x3a2(%r12,%rdx)
movb 0xf8(%r12,%rdx), %sil
cmpb $0x1, %sil
jne 0xb952
cmpl $-0x1, %ecx
je 0xb950
movslq %ecx, %rdi
movss 0x384(%r12,%rdi,4), %xmm0
ucomiss 0x384(%r12,%rdx,4), %xmm0
jbe 0xb952
movl %edx, %ecx
andb $0x1, %al
orb %sil, %al
incq %rdx
cmpq $0x5, %rdx
jne 0xb8fc
cmpl $-0x1, %ecx
je 0xb975
movslq %ecx, %rdx
movb $0x1, %cl
cmpb $0x1, 0x3a2(%r12,%rdx)
jne 0xb981
cmpq $0x0, (%rbx)
jne 0xb998
testb %al, %al
jne 0xb998
xorl %ecx, %ecx
movl 0x1790(%r12), %eax
testl %eax, %eax
je 0xb9fa
movb $0x1, 0x32a(%r12)
jmp 0xb9b3
movl 0x1790(%r12), %eax
movb $0x1, 0x32a(%r12)
testl %eax, %eax
je 0xba55
xorl %ecx, %ecx
movb $0x1, 0x32b(%r12)
cmpl %eax, 0x1ab0(%r12)
sete 0x32c(%r12)
movl $0x0, 0x1940(%r12)
movw $0x0, 0x2df0(%r12)
testb %cl, %cl
je 0xb9f3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xbaeb
xorl %eax, %eax
jmp 0xba87
movb $0x1, %al
cmpl $0x0, 0x17f8(%r12)
movb $0x1, %dl
jne 0xba11
movb 0x2df0(%r12), %dl
movb %dl, 0x32a(%r12)
movb 0x2df1(%r12), %dl
movb %dl, 0x32b(%r12)
movb $0x0, 0x32c(%r12)
movl $0x0, 0x1940(%r12)
movw $0x0, 0x2df0(%r12)
testb %cl, %cl
je 0xba87
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xbab1
movb 0x2df1(%r12), %al
movb %al, 0x32b(%r12)
movb $0x0, 0x32c(%r12)
movl $0x0, 0x1940(%r12)
movw $0x0, 0x2df0(%r12)
movb $0x1, %al
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xbaad
movss 0x100(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xbaa3
jnp 0xbaad
cmpb $0x0, 0x73(%rcx)
je 0xbd17
testb %al, %al
je 0xbaeb
movq 0x1770(%r12), %rax
testq %rax, %rax
je 0xbaeb
cmpb $0x1, 0x70(%rax)
jne 0xbaeb
movq 0x499b5(%rip), %rax     # 0x55480
movl 0x34(%rax), %edi
xorl %esi, %esi
callq 0xedf5
testb %al, %al
je 0xbaeb
movq 0x1770(%r12), %rax
movl $0x0, 0x29c(%rax)
movl 0x1738(%r12), %eax
testq %rax, %rax
je 0xbb31
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xbf6c
movq 0x1740(%r12), %rdi
movq (%rdi,%rsi,8), %rdi
movb 0x70(%rdi), %r8b
movb %r8b, 0x71(%rdi)
movb %cl, 0x70(%rdi)
movb %cl, 0x72(%rdi)
incq %rsi
cmpq %rsi, %rax
jne 0xbb06
cmpl $0x0, 0x1764(%r12)
movq 0x4993f(%rip), %r14     # 0x55480
jns 0xbbad
incl 0x334(%r14)
xorl %edi, %edi
callq *0xd0(%r14)
movq %rax, %rbx
movq 0x1768(%r12), %rsi
movslq 0x1760(%r12), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x1768(%r12), %rdi
movq 0x498ff(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xbb8c
decl 0x334(%rax)
callq *0xd8(%rax)
movq %rbx, 0x1768(%r12)
movl $0x0, 0x1764(%r12)
movq 0x498d3(%rip), %r14     # 0x55480
movl $0x0, 0x1760(%r12)
cmpl $0x0, 0x180c(%r12)
jns 0xbc32
incl 0x334(%r14)
xorl %edi, %edi
callq *0xd0(%r14)
movq %rax, %rbx
movq 0x1810(%r12), %rsi
movslq 0x1808(%r12), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %rbx, %rdi
callq 0x7080
movq 0x1810(%r12), %rdi
movq 0x4987a(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xbc11
decl 0x334(%rax)
callq *0xd8(%rax)
movq %rbx, 0x1810(%r12)
movl $0x0, 0x180c(%r12)
movq 0x4984e(%rip), %r14     # 0x55480
movl $0x0, 0x1808(%r12)
movl 0x17f8(%r14), %eax
testq %rax, %rax
je 0xbf1b
movq 0x1770(%r14), %rcx
testq %rcx, %rcx
sete %dl
testl %eax, %eax
setle %sil
xorl %r15d, %r15d
orb %dl, %sil
jne 0xbcde
movq 0x1800(%r14), %rdx
xorl %r15d, %r15d
leaq (%r15,%r15,4), %rsi
movq 0x8(%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0xbcd1
movl 0xc(%rdi), %esi
btl $0x19, %esi
jae 0xbfaa
btl $0x14, %esi
jb 0xbcd1
movq %r15, %rsi
testq %rdi, %rdi
je 0xbcb9
movq 0x278(%rdi), %rdi
movq 0x278(%rcx), %r8
incq %rsi
cmpq %rax, %rsi
jae 0xbccc
cmpq %r8, %rdi
jne 0xbcc1
jmp 0xbccc
incq %rsi
cmpq %rax, %rsi
jae 0xbcde
leaq (%rsi,%rsi,4), %rdi
movq 0x8(%rdx,%rdi,8), %rdi
jmp 0xbc97
cmpq %r8, %rdi
jne 0xbcde
incq %r15
cmpq %rax, %r15
jne 0xbc73
jmp 0xbf1b
cmpl %eax, %r15d
jge 0xbf1b
movl 0x17fc(%r14), %eax
movq %r14, %rcx
cmpl %r15d, %eax
jge 0xbf11
testl %eax, %eax
je 0xbe95
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0xbe9b
cmpb $0x1, 0x105(%r12)
jne 0xbe2e
cmpb $0x1, 0x9c(%r12)
jne 0xbaad
movss 0x268(%rcx), %xmm2
mulss 0x3167f(%rip), %xmm0    # 0x3d3c4
addss %xmm2, %xmm0
movss 0x31677(%rip), %xmm1    # 0x3d3c8
minss %xmm0, %xmm1
movss 0x3166f(%rip), %xmm3    # 0x3d3cc
cmpltss %xmm3, %xmm0
movaps %xmm0, %xmm4
andnps %xmm1, %xmm4
andps %xmm3, %xmm0
orps %xmm4, %xmm0
movaps %xmm0, %xmm1
divss %xmm2, %xmm1
movss %xmm0, 0x268(%rcx)
movss 0x3160a(%rip), %xmm8    # 0x3d390
subss %xmm1, %xmm8
movss 0x20(%rcx), %xmm2
movss 0x24(%rcx), %xmm0
movaps %xmm2, %xmm3
mulss %xmm8, %xmm3
mulss %xmm0, %xmm8
movss 0xf0(%r12), %xmm4
movss 0xf4(%r12), %xmm5
movss 0x18(%rcx), %xmm6
movss 0x1c(%rcx), %xmm7
subss %xmm6, %xmm4
mulss %xmm3, %xmm4
subss %xmm7, %xmm5
mulss %xmm8, %xmm5
divss %xmm2, %xmm4
divss %xmm0, %xmm5
addss %xmm4, %xmm6
movss %xmm6, 0x18(%rcx)
addss %xmm5, %xmm7
movss %xmm7, 0x1c(%rcx)
addss 0x10(%rcx), %xmm4
movss %xmm4, 0x10(%rcx)
addss 0x14(%rcx), %xmm5
movss %xmm5, 0x14(%rcx)
mulss %xmm1, %xmm2
movss %xmm2, 0x20(%rcx)
mulss %xmm1, %xmm0
movss %xmm0, 0x24(%rcx)
movss 0x28(%rcx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x28(%rcx)
mulss 0x2c(%rcx), %xmm1
movss %xmm1, 0x2c(%rcx)
jmp 0xbaad
movl 0xc(%rcx), %edx
testb $0x10, %dl
jne 0xbaad
xorl %esi, %esi
btl $0x17, %edx
setae %sil
leal 0x3(%rsi,%rsi), %edx
movss 0x50(%rcx), %xmm1
movq 0x4962c(%rip), %rsi     # 0x55480
movss 0x171c(%rsi), %xmm2
cvtsi2ss %edx, %xmm3
mulss 0x268(%rcx), %xmm2
mulss %xmm0, %xmm2
mulss %xmm3, %xmm2
movaps %xmm1, %xmm0
subss %xmm2, %xmm0
addss 0xc4(%rcx), %xmm1
movss %xmm0, 0x50(%rcx)
subss %xmm0, %xmm1
movss %xmm1, 0xc4(%rcx)
jmp 0xbaad
movl $0x8, %r12d
cmpl %r15d, %r12d
cmovlel %r15d, %r12d
leaq (,%r12,8), %rax
leaq (%rax,%rax,4), %rdi
incl 0x334(%r14)
callq *0xd0(%r14)
movq %rax, %rbx
movq 0x1800(%r14), %rsi
movslq 0x17f8(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %rbx, %rdi
callq 0x7080
movq 0x1800(%r14), %rdi
movq 0x49595(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xbef6
decl 0x334(%rax)
callq *0xd8(%rax)
movq %rbx, 0x1800(%r14)
movl %r12d, 0x17fc(%r14)
movq 0x4956f(%rip), %rcx     # 0x55480
movl %r15d, 0x17f8(%r14)
movq %rcx, %r14
movabsq $0x43c8000043c80000, %rax # imm = 0x43C8000043C80000
movq %rax, 0x1820(%r14)
movl $0x4, 0x1838(%r14)
leaq -0xa0(%rbp), %rdx
movq $0x0, (%rdx)
leaq 0x3197f(%rip), %rdi     # 0x3d8cb
movss 0x31448(%rip), %xmm0    # 0x3d39c
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xf554
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32e6d(%rip), %rdi     # 0x3ede0
leaq 0x32b49(%rip), %rsi     # 0x3eac3
leaq 0x332bf(%rip), %rcx     # 0x3f240
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
leaq 0x3188d(%rip), %rdi     # 0x3d81f
leaq 0x3171c(%rip), %rsi     # 0x3d6b5
leaq 0x31868(%rip), %rcx     # 0x3d808
movl $0x70c, %edx            # imm = 0x70C
callq 0x7140
leaq 0x32c5f(%rip), %rdi     # 0x3ec10
leaq 0x316fd(%rip), %rsi     # 0x3d6b5
leaq 0x32c85(%rip), %rcx     # 0x3ec44
movl $0xbf6, %edx            # imm = 0xBF6
callq 0x7140
leaq 0x31821(%rip), %rdi     # 0x3d7f1
leaq 0x316de(%rip), %rsi     # 0x3d6b5
leaq 0x3182a(%rip), %rcx     # 0x3d808
movl $0x70b, %edx            # imm = 0x70B
callq 0x7140
leaq 0x31869(%rip), %rdi     # 0x3d858
leaq 0x316bf(%rip), %rsi     # 0x3d6b5
leaq 0x3180b(%rip), %rcx     # 0x3d808
movl $0x70d, %edx            # imm = 0x70D
callq 0x7140
leaq 0x31865(%rip), %rdi     # 0x3d873
leaq 0x316a0(%rip), %rsi     # 0x3d6b5
leaq 0x317ec(%rip), %rcx     # 0x3d808
movl $0x70e, %edx            # imm = 0x70E
callq 0x7140
leaq 0x31867(%rip), %rdi     # 0x3d894
leaq 0x31681(%rip), %rsi     # 0x3d6b5
leaq 0x317cd(%rip), %rcx     # 0x3d808
movl $0x70f, %edx            # imm = 0x70F
callq 0x7140
leaq 0x3186c(%rip), %rdi     # 0x3d8b8
leaq 0x31662(%rip), %rsi     # 0x3d6b5
leaq 0x317ae(%rip), %rcx     # 0x3d808
movl $0x717, %edx            # imm = 0x717
callq 0x7140
leaq 0x32d75(%rip), %rdi     # 0x3ede0
leaq 0x32a51(%rip), %rsi     # 0x3eac3
leaq 0x33210(%rip), %rcx     # 0x3f289
jmp 0xbf81