// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a22b(%rip), %r12     # 0x55490
movss 0x10(%r12), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0xc0e2
movss 0x8(%r12), %xmm1
ucomiss %xmm0, %xmm1
jb 0xc0c3
movss 0xc(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xc0c3
movq 0x90(%r12), %rax
cmpl $0x0, 0x30(%rax)
jle 0xc101
movq 0x38(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0xc120
movss 0x145c(%r12), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc13f
cmpb $0x0, (%r12)
jne 0xb4e3
incl 0x334(%r12)
movl $0x10, %edi
callq *0xd0(%r12)
movq %rax, 0x2bf8(%r12)
movq %rax, %rdi
callq 0x2488e
cmpl $0x0, 0x17b0(%r12)
jne 0xc178
movq 0x4a178(%rip), %rax     # 0x55490
movq %rax, -0x60(%rbp)
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xb4de
leaq 0x3373e(%rip), %rsi     # 0x3ea6e
leaq -0x34(%rbp), %rdx
movl $0x1, %ecx
callq 0x8f24
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0xb4de
movslq -0x34(%rbp), %rax
testq %rax, %rax
jle 0xb4c7
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 0xb380
cmpl $0xd, %ecx
je 0xb380
incq %rbx
cmpq %r13, %rbx
jb 0xb36b
cmpq %r15, %rbx
jbe 0xb3da
cmpb $0x5b, (%r15)
jne 0xb3da
cmpb $0x5d, -0x1(%rbx)
jne 0xb3da
movl %ebx, %ecx
subl %r15d, %ecx
addl $-0x2, %ecx
incq %r15
leaq -0xa0(%rbp), %rdi
movl $0x40, %esi
leaq 0x3382c(%rip), %rdx     # 0x3ebdb
movq %r15, %r8
movq %rdi, %r15
xorl %eax, %eax
callq 0x86d8
movq %r15, %rdi
callq 0x2352f
testq %rax, %rax
jne 0xb4b8
movq %r15, %rdi
callq 0x235b3
jmp 0xb4b8
testq %rax, %rax
je 0xb41b
movq %rax, -0x50(%rbp)
movq %r15, %rdi
leaq 0x33684(%rip), %rsi     # 0x3ea71
movq %r14, %rcx
leaq -0xa0(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xb422
movl -0xa0(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %edx, 0xc(%rax)
movl %ecx, 0x10(%rax)
jmp 0xb4b8
xorl %eax, %eax
jmp 0xb4b8
movq %r15, %rdi
leaq 0x3364f(%rip), %rsi     # 0x3ea7b
leaq -0xa0(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xb492
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 0xb4b8
movq %r15, %rdi
leaq 0x335ea(%rip), %rsi     # 0x3ea86
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x1, %eax
movq -0x50(%rbp), %rax
jne 0xb4b8
cmpl $0x0, -0x30(%rbp)
setne 0x1c(%rax)
incq %rbx
movq %rbx, %r15
cmpq %r13, %rbx
jb 0xb36b
movq 0x49fc2(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq -0x58(%rbp), %rdi
callq *0xd8(%rax)
movb $0x1, (%r12)
movq 0x90(%r12), %rax
cmpl $0x0, 0x30(%rax)
jle 0xc15e
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0xc197
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 0x2cd04
movq 0x90(%r12), %rsi
movq %rbx, %rdi
callq 0x2d60a
movq %rbx, %rdi
callq 0x2d52c
movq %rbx, %rdi
callq 0x2d104
movb %r14b, 0x1850(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x1858(%r12)
movl $0x0, 0x1868(%r12)
xorps %xmm1, %xmm1
ucomiss 0xf0(%r12), %xmm1
jbe 0xb5aa
ucomiss 0xf4(%r12), %xmm1
jbe 0xb5aa
movabsq $-0x39e3c3ff39e3c400, %rax # imm = 0xC61C3C00C61C3C00
movq %rax, 0xf0(%r12)
movss 0xf0(%r12), %xmm0
ucomiss %xmm0, %xmm1
jbe 0xb5c4
ucomiss 0xf4(%r12), %xmm1
ja 0xb5e1
movss 0x344(%r12), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm1, %xmm2
jbe 0xb5ef
ucomiss 0x348(%r12), %xmm2
jbe 0xb5ef
movq $0x0, 0x34c(%r12)
jmp 0xb613
subss %xmm1, %xmm0
movss 0xf4(%r12), %xmm1
subss 0x348(%r12), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x34c(%r12)
movq 0xf0(%r12), %rax
movq %rax, 0x344(%r12)
xorl %eax, %eax
movss 0x31d5f(%rip), %xmm0    # 0x3d38c
xorps %xmm1, %xmm1
movss 0x31d74(%rip), %xmm2    # 0x3d3ac
xorl %ecx, %ecx
movss 0x3a8(%r12,%rcx,4), %xmm3
movss %xmm3, 0x3bc(%r12,%rcx,4)
movb 0xf8(%r12,%rcx), %dl
movaps %xmm0, %xmm4
cmpb $0x1, %dl
jne 0xb671
xorps %xmm4, %xmm4
ucomiss %xmm3, %xmm4
ja 0xb671
movss 0x10(%r12), %xmm4
addss %xmm3, %xmm4
ucomiss %xmm1, %xmm4
setnp %sil
sete %dil
andb %sil, %dil
movl %edx, %esi
xorb $0x1, %sil
ucomiss %xmm1, %xmm3
movzbl %sil, %esi
cmovbl %eax, %esi
ucomiss %xmm1, %xmm4
movss %xmm4, 0x3a8(%r12,%rcx,4)
movb %dil, 0x354(%r12,%rcx)
movb %sil, 0x39d(%r12,%rcx)
movb $0x0, 0x398(%r12,%rcx)
jne 0xb75f
jp 0xb75f
movss 0x1728(%r12), %xmm3
movaps %xmm3, %xmm4
subss 0x384(%r12,%rcx,4), %xmm4
movss 0x28(%r12), %xmm5
ucomiss %xmm4, %xmm5
jbe 0xb737
movss 0xf0(%r12), %xmm3
subss 0x35c(%r12,%rcx,8), %xmm3
movss 0xf4(%r12), %xmm4
subss 0x360(%r12,%rcx,8), %xmm4
movss 0x2c(%r12), %xmm5
mulss %xmm4, %xmm4
mulss %xmm3, %xmm3
addss %xmm4, %xmm3
mulss %xmm5, %xmm5
ucomiss %xmm3, %xmm5
movaps %xmm2, %xmm3
jbe 0xb737
movb $0x1, 0x398(%r12,%rcx)
movaps %xmm2, %xmm3
movss %xmm3, 0x384(%r12,%rcx,4)
movq 0xf0(%r12), %rdx
movq %rdx, 0x35c(%r12,%rcx,8)
movl $0x0, 0x3d0(%r12,%rcx,4)
jmp 0xb7bf
testb %dl, %dl
je 0xb7bf
movss 0x3d0(%r12,%rcx,4), %xmm3
movss 0xf0(%r12), %xmm4
movss 0xf4(%r12), %xmm5
subss 0x35c(%r12,%rcx,8), %xmm4
subss 0x360(%r12,%rcx,8), %xmm5
mulss %xmm5, %xmm5
mulss %xmm4, %xmm4
addss %xmm5, %xmm4
movaps %xmm4, %xmm5
cmpless %xmm3, %xmm5
movaps %xmm5, %xmm6
andnps %xmm4, %xmm6
andps %xmm3, %xmm5
orps %xmm6, %xmm5
movss %xmm5, 0x3d0(%r12,%rcx,4)
incq %rcx
cmpq $0x5, %rcx
jne 0xb63a
leaq 0xbe4(%r12), %rdi
leaq 0x3e4(%r12), %rbx
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rsi
callq 0x7080
xorl %eax, %eax
movss 0x31b99(%rip), %xmm0    # 0x3d38c
cmpb $0x1, -0x2dc(%rbx,%rax)
movaps %xmm0, %xmm1
jne 0xb817
movss (%rbx,%rax,4), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm2, %xmm1
ja 0xb817
addss 0x10(%r12), %xmm2
movaps %xmm2, %xmm1
movss %xmm1, (%rbx,%rax,4)
incq %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0xb7f3
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), %xmm0
divss 0x31b11(%rip), %xmm0    # 0x3d3b0
movss 0x31ad9(%rip), %xmm1    # 0x3d380
divss %xmm0, %xmm1
movss %xmm1, 0x330(%r12)
movl 0x1788(%r12), %eax
movl %eax, 0x178c(%r12)
movl $0x0, 0x1788(%r12)
cmpb $0x0, 0x1798(%r12)
jne 0xb91d
movl 0x1790(%r12), %eax
cmpl %eax, 0x1794(%r12)
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0xb91d
movq 0x49b91(%rip), %rax     # 0x55490
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 0xb948
movq $0x0, 0x17a8(%r12)
movss 0x17c0(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xb975
subss 0x10(%r12), %xmm0
movss %xmm0, 0x17c0(%r12)
ucomiss %xmm0, %xmm1
jb 0xb975
callq 0xc246
movsd 0xf0(%r12), %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %edi, %edi
callq 0xc442
movq %rax, 0x1778(%r12)
testq %rax, %rax
je 0xb99d
testb $0x10, 0xe(%rax)
jne 0xb9ad
movaps -0x50(%rbp), %xmm0
movl $0x1, %edi
callq 0xc442
jmp 0xb9b4
movq 0x278(%rax), %rax
leaq 0x1778(%r12), %rbx
movq %rax, 0x1780(%r12)
callq 0xc521
testq %rax, %rax
je 0xba0b
movss 0x10(%r12), %xmm0
mulss 0x319b7(%rip), %xmm0    # 0x3d394
addss 0x18a0(%r12), %xmm0
minss 0x31991(%rip), %xmm0    # 0x3d380
movss %xmm0, 0x18a0(%r12)
cmpq %rax, 0x1780(%r12)
je 0xba17
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xba17
movl $0x0, 0x18a0(%r12)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x1, 0x354(%r12,%rdx)
jne 0xba49
movb $0x1, %sil
cmpq $0x0, (%rbx)
jne 0xba41
cmpl $0x0, 0x17f8(%r12)
setne %sil
movb %sil, 0x3a2(%r12,%rdx)
movb 0xf8(%r12,%rdx), %sil
cmpb $0x1, %sil
jne 0xba76
cmpl $-0x1, %ecx
je 0xba74
movslq %ecx, %rdi
movss 0x384(%r12,%rdi,4), %xmm0
ucomiss 0x384(%r12,%rdx,4), %xmm0
jbe 0xba76
movl %edx, %ecx
andb $0x1, %al
orb %sil, %al
incq %rdx
cmpq $0x5, %rdx
jne 0xba20
cmpl $-0x1, %ecx
je 0xba99
movslq %ecx, %rcx
movb 0x3a2(%r12,%rcx), %cl
xorb $0x1, %cl
jmp 0xba9b
xorl %ecx, %ecx
testb %cl, %cl
jne 0xbaab
cmpq $0x0, (%rbx)
movb $0x1, %dl
jne 0xbacb
testb %al, %al
jne 0xbacb
movb $0x1, %dl
cmpl $0x0, 0x1790(%r12)
jne 0xbacb
cmpl $0x0, 0x17f8(%r12)
jne 0xbacb
movb 0x2df0(%r12), %dl
movb %dl, 0x32a(%r12)
movl 0x1790(%r12), %eax
testl %eax, %eax
je 0xbaf5
movb $0x1, 0x32b(%r12)
cmpl %eax, 0x1ab0(%r12)
sete %dl
jmp 0xbb07
movb 0x2df1(%r12), %dl
movb %dl, 0x32b(%r12)
xorl %edx, %edx
movb %dl, 0x32c(%r12)
movl $0x0, 0x1940(%r12)
movw $0x0, 0x2df0(%r12)
testb %cl, %cl
je 0xbb30
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xbb56
movss 0x100(%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xbb4c
jnp 0xbb56
cmpb $0x0, 0x73(%rcx)
je 0xbe29
testl %eax, %eax
je 0xbdde
movl 0x1738(%r12), %eax
testq %rax, %rax
je 0xbba4
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xc085
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 0xbb79
movl 0x1764(%r12), %eax
testl %eax, %eax
jns 0xbc39
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovgl %ecx, %r14d
leaq (,%r14,8), %rdi
movq 0x498b9(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %rbx
movq 0x1768(%r12), %rsi
movslq 0x1760(%r12), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x1768(%r12), %rdi
testq %rdi, %rdi
je 0xbc1c
movq 0x4987a(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4986d(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %rbx, 0x1768(%r12)
movl %r14d, 0x1764(%r12)
movl $0x0, 0x1760(%r12)
movl 0x180c(%r12), %eax
testl %eax, %eax
jns 0xbce2
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovgl %ecx, %r14d
leaq (,%r14,8), %rax
leaq (%rax,%rax,4), %rdi
movq 0x49814(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
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
testq %rdi, %rdi
je 0xbcc5
movq 0x497d1(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x497c4(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %rbx, 0x1810(%r12)
movl %r14d, 0x180c(%r12)
movl $0x0, 0x1808(%r12)
movq 0x4979b(%rip), %r14     # 0x55490
movl 0x17f8(%r14), %eax
testq %rax, %rax
je 0xc02e
movq 0x1770(%r14), %rcx
testq %rcx, %rcx
sete %dl
testl %eax, %eax
setle %sil
xorl %r15d, %r15d
orb %dl, %sil
jne 0xbda8
movq 0x1800(%r14), %rdx
leaq 0x8(%rdx), %rsi
movl $0x1, %edi
xorl %r15d, %r15d
leaq (%r15,%r15,4), %r8
movq 0x8(%rdx,%r8,8), %r8
testq %r8, %r8
je 0xbd96
movl 0xc(%r8), %r8d
btl $0x19, %r8d
jae 0xc0a4
btl $0x14, %r8d
movq %rsi, %r8
movq %rdi, %r9
jb 0xbd96
movq (%r8), %r10
testq %r10, %r10
je 0xbd7d
movq 0x278(%r10), %r10
cmpq 0x278(%rcx), %r10
sete %r10b
jmp 0xbd80
xorl %r10d, %r10d
cmpq %rax, %r9
jae 0xbd91
incq %r9
addq $0x28, %r8
testb %r10b, %r10b
je 0xbd61
testb %r10b, %r10b
je 0xbda8
incq %r15
incq %rdi
addq $0x28, %rsi
cmpq %rax, %r15
jne 0xbd37
movl %eax, %r15d
cmpl %eax, %r15d
jge 0xc02e
movl 0x17fc(%r14), %eax
cmpl %r15d, %eax
jge 0xc027
testl %eax, %eax
je 0xbfa7
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0xbfad
movq 0x1770(%r12), %rax
testq %rax, %rax
je 0xbb5e
cmpb $0x1, 0x70(%rax)
jne 0xbb5e
movq 0x49690(%rip), %rax     # 0x55490
movl 0x34(%rax), %edi
xorl %esi, %esi
callq 0xf076
testb %al, %al
je 0xbb5e
movq 0x1770(%r12), %rax
movl $0x0, 0x29c(%rax)
jmp 0xbb5e
cmpb $0x1, 0x105(%r12)
jne 0xbf40
cmpb $0x1, 0x9c(%r12)
jne 0xbb56
movss 0x268(%rcx), %xmm2
mulss 0x3155d(%rip), %xmm0    # 0x3d3b4
addss %xmm2, %xmm0
movss 0x31555(%rip), %xmm1    # 0x3d3b8
minss %xmm0, %xmm1
movss 0x3154d(%rip), %xmm3    # 0x3d3bc
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 0x314e8(%rip), %xmm8    # 0x3d380
subss %xmm1, %xmm8
movss 0x20(%rcx), %xmm0
movaps %xmm0, %xmm3
mulss %xmm8, %xmm3
movss 0x24(%rcx), %xmm2
mulss %xmm2, %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 %xmm0, %xmm4
divss %xmm2, %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, %xmm0
movss %xmm0, 0x20(%rcx)
mulss %xmm1, %xmm2
movss %xmm2, 0x24(%rcx)
movss 0x28(%rcx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x28(%rcx)
mulss 0x2c(%rcx), %xmm1
movss %xmm1, 0x2c(%rcx)
jmp 0xbb56
movl 0xc(%rcx), %edx
testb $0x10, %dl
jne 0xbb56
xorl %esi, %esi
btl $0x17, %edx
setae %sil
leal 0x3(%rsi,%rsi), %edx
movss 0x50(%rcx), %xmm1
movq 0x4952a(%rip), %rsi     # 0x55490
movss 0x171c(%rsi), %xmm2
mulss 0x268(%rcx), %xmm2
cvtsi2ss %edx, %xmm3
mulss %xmm0, %xmm2
mulss %xmm3, %xmm2
movaps %xmm1, %xmm0
addss 0xc4(%rcx), %xmm1
subss %xmm2, %xmm0
movss %xmm0, 0x50(%rcx)
subss %xmm0, %xmm1
movss %xmm1, 0xc4(%rcx)
jmp 0xbb56
movl $0x8, %r12d
cmpl %r15d, %r12d
cmovlel %r15d, %r12d
cmpl %r12d, %eax
jge 0xc027
movl %r12d, %eax
shlq $0x3, %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
testq %rdi, %rdi
je 0xc00c
movq 0x4948a(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4947d(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %rbx, 0x1800(%r14)
movl %r12d, 0x17fc(%r14)
movl %r15d, 0x17f8(%r14)
movq 0x4945b(%rip), %rax     # 0x55490
movabsq $0x43c8000043c80000, %rcx # imm = 0x43C8000043C80000
movq %rcx, 0x1820(%rax)
movl $0x4, 0x1838(%rax)
leaq -0xa0(%rbp), %rdx
movq $0x0, (%rdx)
leaq 0x31836(%rip), %rdi     # 0x3d89b
movss 0x3131f(%rip), %xmm0    # 0x3d38c
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xf7d7
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32d24(%rip), %rdi     # 0x3edb0
leaq 0x32a00(%rip), %rsi     # 0x3ea93
leaq 0x33176(%rip), %rcx     # 0x3f210
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
leaq 0x32b35(%rip), %rdi     # 0x3ebe0
leaq 0x315d3(%rip), %rsi     # 0x3d685
leaq 0x32b5b(%rip), %rcx     # 0x3ec14
movl $0xbf6, %edx            # imm = 0xBF6
callq 0x7140
leaq 0x31725(%rip), %rdi     # 0x3d7ef
leaq 0x315b4(%rip), %rsi     # 0x3d685
leaq 0x31700(%rip), %rcx     # 0x3d7d8
movl $0x70c, %edx            # imm = 0x70C
callq 0x7140
leaq 0x316d8(%rip), %rdi     # 0x3d7c1
leaq 0x31595(%rip), %rsi     # 0x3d685
leaq 0x316e1(%rip), %rcx     # 0x3d7d8
movl $0x70b, %edx            # imm = 0x70B
callq 0x7140
leaq 0x31720(%rip), %rdi     # 0x3d828
leaq 0x31576(%rip), %rsi     # 0x3d685
leaq 0x316c2(%rip), %rcx     # 0x3d7d8
movl $0x70d, %edx            # imm = 0x70D
callq 0x7140
leaq 0x3171c(%rip), %rdi     # 0x3d843
leaq 0x31557(%rip), %rsi     # 0x3d685
leaq 0x316a3(%rip), %rcx     # 0x3d7d8
movl $0x70e, %edx            # imm = 0x70E
callq 0x7140
leaq 0x3171e(%rip), %rdi     # 0x3d864
leaq 0x31538(%rip), %rsi     # 0x3d685
leaq 0x31684(%rip), %rcx     # 0x3d7d8
movl $0x70f, %edx            # imm = 0x70F
callq 0x7140
leaq 0x32c4b(%rip), %rdi     # 0x3edb0
leaq 0x32927(%rip), %rsi     # 0x3ea93
leaq 0x330e6(%rip), %rcx     # 0x3f259
jmp 0xc09a
leaq 0x31709(%rip), %rdi     # 0x3d888
leaq 0x314ff(%rip), %rsi     # 0x3d685
leaq 0x3164b(%rip), %rcx     # 0x3d7d8
movl $0x717, %edx            # imm = 0x717
callq 0x7140