// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq 0x46307(%rip), %rbx     # 0x50480
movss 0x10(%rbx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0xacec
movss 0x8(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jb 0xaccd
movss 0xc(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xaccd
movq 0x90(%rbx), %rdi
cmpl $0x0, 0x30(%rdi)
jle 0xad0b
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1e75e
movq (%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0xad2a
movss 0x145c(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xad49
cmpb $0x0, (%rbx)
jne 0xa3ee
movq 0x46289(%rip), %rax     # 0x50480
incl 0x334(%rax)
pushq $0x10
popq %rdi
callq *0xd0(%rax)
movq %rax, 0x2bf8(%rbx)
movq %rax, %rdi
callq 0x1e792
cmpl $0x0, 0x17b0(%rbx)
jne 0xad68
movq 0x46257(%rip), %rax     # 0x50480
movq %rax, -0x50(%rbp)
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xa3eb
leaq 0x2d815(%rip), %rsi     # 0x37a56
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x8bd2
testq %rax, %rax
je 0xa3eb
movslq -0x40(%rbp), %r13
addq %rax, %r13
leaq -0x2c(%rbp), %r14
xorl %edx, %edx
movq %rax, -0x48(%rbp)
movq %rax, %r12
cmpq %r13, %r12
jae 0xa3d4
pushq $-0x2
popq %rcx
movq %r12, %r15
cmpq %r13, %r15
jae 0xa293
movzbl (%r15), %eax
cmpl $0xa, %eax
je 0xa293
cmpl $0xd, %eax
je 0xa293
incq %r15
incl %ecx
jmp 0xa279
cmpq %r12, %r15
jbe 0xa2eb
cmpb $0x5b, (%r12)
jne 0xa2eb
cmpb $0x5d, -0x1(%r15)
jne 0xa2eb
incq %r12
leaq -0x90(%rbp), %rdi
pushq $0x40
popq %rsi
leaq 0x2d93e(%rip), %rdx     # 0x37bf8
movq %r12, %r8
movq %rdi, %r12
xorl %eax, %eax
callq 0x83b1
movq %r12, %rdi
callq 0x1d30a
movq %rax, %rdx
testq %rax, %rax
jne 0xa3c9
movq %r12, %rdi
callq 0x1d35b
movq %rax, %rdx
jmp 0xa3c9
testq %rdx, %rdx
je 0xa32c
movq %rdx, -0x38(%rbp)
movq %r12, %rdi
leaq 0x2d75b(%rip), %rsi     # 0x37a59
movq %r14, %rcx
leaq -0x90(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xa333
movl -0x90(%rbp), %eax
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rdx
movl %eax, 0xc(%rdx)
movl %ecx, 0x10(%rdx)
jmp 0xa3c9
xorl %edx, %edx
jmp 0xa3c9
movq %r12, %rdi
leaq 0x2d726(%rip), %rsi     # 0x37a63
leaq -0x90(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x70c0
cmpl $0x2, %eax
jne 0xa3a3
movss -0x90(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movq -0x50(%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 -0x38(%rbp), %rdx
movlps %xmm4, 0x14(%rdx)
jmp 0xa3c9
movq %r12, %rdi
leaq 0x2d6c1(%rip), %rsi     # 0x37a6e
leaq -0x3c(%rbp), %rdx
xorl %eax, %eax
callq 0x70c0
cmpl $0x1, %eax
movq -0x38(%rbp), %rdx
jne 0xa3c9
cmpl $0x0, -0x3c(%rbp)
setne 0x1c(%rdx)
incq %r15
movq %r15, %r12
jmp 0xa26a
movq 0x460a5(%rip), %rax     # 0x50480
decl 0x334(%rax)
movq -0x48(%rbp), %rdi
callq *0xd8(%rax)
movb $0x1, (%rbx)
movq 0x90(%rbx), %rdi
addq $0x30, %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1e75e
movq (%rax), %rdi
callq 0xad87
movss 0x10(%rbx), %xmm0
addss 0x1728(%rbx), %xmm0
movss %xmm0, 0x1728(%rbx)
incl 0x172c(%rbx)
movb %r15b, 0x27e0(%rbx)
leaq 0x18a8(%rbx), %r14
movq %r14, %rdi
callq 0x27a88
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x27e64
movq %r14, %rdi
callq 0x27daa
movq %r14, %rdi
callq 0x27baa
movb %r15b, 0x1850(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1858(%rbx)
andl $0x0, 0x1868(%rbx)
movss 0xf0(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xa4a7
ucomiss 0xf4(%rbx), %xmm1
jbe 0xa4a7
movabsq $-0x39e3c3ff39e3c400, %rax # imm = 0xC61C3C00C61C3C00
movq %rax, 0xf0(%rbx)
movss 0x2bf17(%rip), %xmm0    # 0x363bc
jmp 0xa4ac
ucomiss %xmm0, %xmm1
jbe 0xa4b5
ucomiss 0xf4(%rbx), %xmm1
ja 0xa4d2
movss 0x344(%rbx), %xmm2
movss 0x348(%rbx), %xmm1
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jbe 0xa4dc
ucomiss %xmm1, %xmm3
jbe 0xa4dc
andq $0x0, 0x34c(%rbx)
jmp 0xa4f6
subss %xmm2, %xmm0
movss 0xf4(%rbx), %xmm2
subss %xmm1, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movlps %xmm0, 0x34c(%rbx)
movq 0xf0(%rbx), %rax
movq %rax, 0x344(%rbx)
movq %rax, %rcx
shrq $0x20, %rcx
movd %ecx, %xmm0
movd %eax, %xmm1
xorl %ecx, %ecx
movss 0x2be7f(%rip), %xmm2    # 0x3639c
xorps %xmm3, %xmm3
movss 0x2be98(%rip), %xmm4    # 0x363c0
xorl %edx, %edx
cmpq $0x5, %rdx
je 0xa685
movss 0x3a8(%rbx,%rdx,4), %xmm5
movss %xmm5, 0x3bc(%rbx,%rdx,4)
movb 0xf8(%rbx,%rdx), %sil
movaps %xmm2, %xmm6
cmpb $0x1, %sil
jne 0xa568
xorps %xmm6, %xmm6
ucomiss %xmm5, %xmm6
ja 0xa568
movss 0x10(%rbx), %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(%rbx,%rdx,4)
movb %r8b, 0x354(%rbx,%rdx)
movb %dil, 0x39d(%rbx,%rdx)
movb $0x0, 0x398(%rbx,%rdx)
jne 0xa629
jp 0xa629
movss 0x1728(%rbx), %xmm5
movaps %xmm5, %xmm6
subss 0x384(%rbx,%rdx,4), %xmm6
movss 0x28(%rbx), %xmm7
ucomiss %xmm6, %xmm7
jbe 0xa60e
movdqa %xmm1, %xmm5
subss 0x35c(%rbx,%rdx,8), %xmm5
movdqa %xmm0, %xmm6
subss 0x360(%rbx,%rdx,8), %xmm6
mulss %xmm6, %xmm6
mulss %xmm5, %xmm5
addss %xmm6, %xmm5
movss 0x2c(%rbx), %xmm6
mulss %xmm6, %xmm6
ucomiss %xmm5, %xmm6
movaps %xmm4, %xmm5
jbe 0xa60e
movb $0x1, 0x398(%rbx,%rdx)
movaps %xmm4, %xmm5
movss %xmm5, 0x384(%rbx,%rdx,4)
movq %rax, 0x35c(%rbx,%rdx,8)
andl $0x0, 0x3d0(%rbx,%rdx,4)
jmp 0xa67d
testb %sil, %sil
je 0xa67d
movss 0x3d0(%rbx,%rdx,4), %xmm5
movdqa %xmm1, %xmm6
subss 0x35c(%rbx,%rdx,8), %xmm6
movdqa %xmm0, %xmm7
subss 0x360(%rbx,%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(%rbx,%rdx,4)
incq %rdx
jmp 0xa52a
leaq 0xbe4(%rbx), %rdi
leaq 0x3e4(%rbx), %r14
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
callq 0x7080
xorl %eax, %eax
movss 0x2bcf2(%rip), %xmm0    # 0x3639c
cmpq $0x200, %rax            # imm = 0x200
je 0xa6e1
cmpb $0x1, -0x2dc(%r14,%rax)
movaps %xmm0, %xmm1
jne 0xa6d6
movss (%r14,%rax,4), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm2, %xmm1
ja 0xa6d6
addss 0x10(%rbx), %xmm2
movaps %xmm2, %xmm1
movss %xmm1, (%r14,%rax,4)
incq %rax
jmp 0xa6aa
movss 0x10(%rbx), %xmm0
movslq 0x2de8(%rbx), %rax
movaps %xmm0, %xmm1
subss 0x2c08(%rbx,%rax,4), %xmm1
addss 0x2dec(%rbx), %xmm1
movss %xmm1, 0x2dec(%rbx)
movss %xmm0, 0x2c08(%rbx,%rax,4)
incl %eax
pushq $0x78
popq %rcx
cltd
idivl %ecx
movl %edx, 0x2de8(%rbx)
movss 0x2dec(%rbx), %xmm1
divss 0x2bc94(%rip), %xmm1    # 0x363c4
movss 0x2bc58(%rip), %xmm2    # 0x36390
divss %xmm1, %xmm2
movss %xmm2, 0x330(%rbx)
movl 0x1788(%rbx), %eax
movl %eax, 0x178c(%rbx)
andl $0x0, 0x1788(%rbx)
cmpb $0x0, 0x1798(%rbx)
jne 0xa797
movl 0x1790(%rbx), %eax
cmpl %eax, 0x1794(%rbx)
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0xa797
movq 0x45d01(%rip), %rax     # 0x50480
andl $0x0, 0x1790(%rax)
movw $0x1, 0x1799(%rax)
andq $0x0, 0x17a0(%rax)
movl 0x1790(%rbx), %eax
movl %eax, 0x1794(%rbx)
andw $0x0, 0x1798(%rbx)
testl %eax, %eax
jne 0xa7b7
andq $0x0, 0x17a8(%rbx)
movss 0x17c0(%rbx), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jbe 0xa7dd
subss %xmm0, %xmm1
movss %xmm1, 0x17c0(%rbx)
ucomiss %xmm1, %xmm2
jb 0xa7dd
callq 0xae36
movsd 0xf0(%rbx), %xmm0
xorl %edi, %edi
callq 0xafab
movq %rax, 0x1778(%rbx)
testq %rax, %rax
je 0xa7fe
testb $0x10, 0xe(%rax)
jne 0xa810
movsd 0xf0(%rbx), %xmm0
pushq $0x1
popq %rdi
callq 0xafab
jmp 0xa817
movq 0x278(%rax), %rax
leaq 0x1778(%rbx), %r14
movq %rax, 0x1780(%rbx)
callq 0xb07e
testq %rax, %rax
je 0xa866
movss 0x10(%rbx), %xmm0
mulss 0x2bb68(%rip), %xmm0    # 0x363a4
addss 0x18a0(%rbx), %xmm0
minss 0x2bb44(%rip), %xmm0    # 0x36390
movss %xmm0, 0x18a0(%rbx)
cmpq %rax, 0x1780(%rbx)
je 0xa86d
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0xa86d
andl $0x0, 0x18a0(%rbx)
pushq $-0x1
popq %rcx
xorl %edx, %edx
xorl %eax, %eax
movslq %ecx, %rsi
cmpq $0x5, %rdx
je 0xa8d5
cmpb $0x1, 0x354(%rbx,%rdx)
jne 0xa8a3
movb $0x1, %dil
cmpq $0x0, (%r14)
jne 0xa89b
cmpl $0x0, 0x17f8(%rbx)
setne %dil
movb %dil, 0x3a2(%rbx,%rdx)
movb 0xf8(%rbx,%rdx), %dil
cmpb $0x1, %dil
jne 0xa8cb
cmpl $-0x1, %ecx
je 0xa8c9
movss 0x384(%rbx,%rsi,4), %xmm0
ucomiss 0x384(%rbx,%rdx,4), %xmm0
jbe 0xa8cb
movl %edx, %ecx
andb $0x1, %al
orb %dil, %al
incq %rdx
jmp 0xa874
cmpl $-0x1, %ecx
je 0xa8e6
movb $0x1, %cl
cmpb $0x1, 0x3a2(%rbx,%rsi)
jne 0xa90b
cmpq $0x0, (%r14)
setne %cl
orb %al, %cl
testb $0x1, %cl
je 0xa909
movl 0x1790(%rbx), %eax
movb $0x1, 0x32a(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
jne 0xa91c
jmp 0xa947
xorl %ecx, %ecx
movl 0x1790(%rbx), %eax
testl %eax, %eax
je 0xa930
movb $0x1, 0x32a(%rbx)
movb $0x1, 0x32b(%rbx)
cmpl %eax, 0x1ab0(%rbx)
sete %dl
xorl %eax, %eax
jmp 0xa957
movb $0x1, %al
cmpl $0x0, 0x17f8(%rbx)
jne 0xa941
movb 0x2df0(%rbx), %al
movb %al, 0x32a(%rbx)
movb 0x2df1(%rbx), %al
movb %al, 0x32b(%rbx)
movb $0x1, %al
xorl %edx, %edx
movb %dl, 0x32c(%rbx)
andl $0x0, 0x1940(%rbx)
andw $0x0, 0x2df0(%rbx)
testb %cl, %cl
je 0xa979
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0xa99d
movq (%r14), %rcx
testq %rcx, %rcx
je 0xa99d
movss 0x100(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xa993
jnp 0xa99d
cmpb $0x0, 0x73(%rcx)
je 0xab38
testb %al, %al
je 0xa9ce
movq 0x1770(%rbx), %rax
testq %rax, %rax
je 0xa9ce
cmpb $0x1, 0x70(%rax)
jne 0xa9ce
xorl %edi, %edi
xorl %esi, %esi
callq 0x9ea6
testb %al, %al
je 0xa9ce
movq 0x1770(%rbx), %rax
andl $0x0, 0x29c(%rax)
leaq 0x1738(%rbx), %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpl (%r14), %r15d
je 0xaa01
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rax
movb 0x70(%rax), %cl
movb %cl, 0x71(%rax)
movb %r12b, 0x70(%rax)
movb %r12b, 0x72(%rax)
incl %r15d
jmp 0xa9db
leaq 0x1760(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x1e7ce
addq $0x1808, %rbx           # imm = 0x1808
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1e80c
movq 0x45a56(%rip), %r12     # 0x50480
movl 0x17f8(%r12), %eax
testl %eax, %eax
je 0xaaf7
leaq 0x17f8(%r12), %rbx
cmpq $0x0, 0x1770(%r12)
je 0xaae7
xorl %r14d, %r14d
cmpl %eax, %r14d
jge 0xaae7
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1ebd4
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xaadd
movl 0xc(%rax), %eax
btl $0x19, %eax
jae 0xacae
btl $0x14, %eax
jb 0xaadd
xorl %ecx, %ecx
movl %r14d, %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jge 0xaad8
testb $0x1, %cl
jne 0xaad8
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1ebd4
cmpq $0x0, 0x8(%rax)
je 0xaad1
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1ebd4
movq 0x8(%rax), %rax
movq 0x278(%rax), %rax
movq 0x1770(%r12), %rcx
cmpq 0x278(%rcx), %rax
sete %cl
jmp 0xaad3
xorl %ecx, %ecx
incl %r15d
jmp 0xaa89
testb $0x1, %cl
je 0xaae7
incl %r14d
movl (%rbx), %eax
jmp 0xaa54
cmpl %eax, %r14d
jge 0xaaf7
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1e80c
movq 0x45982(%rip), %rax     # 0x50480
movabsq $0x43c8000043c80000, %rcx # imm = 0x43C8000043C80000
movq %rcx, 0x1820(%rax)
movl $0x4, 0x1838(%rax)
leaq 0x2bd63(%rip), %rdi     # 0x36883
xorl %esi, %esi
xorl %edx, %edx
callq 0xb0d4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x105(%rbx)
jne 0xac47
cmpb $0x1, 0x9c(%rbx)
jne 0xa99d
movss 0x268(%rcx), %xmm2
mulss 0x2b866(%rip), %xmm0    # 0x363c8
addss %xmm2, %xmm0
movss 0x2b85e(%rip), %xmm1    # 0x363cc
minss %xmm0, %xmm1
movss 0x2b856(%rip), %xmm3    # 0x363d0
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 0x2b7ed(%rip), %xmm8    # 0x36390
subss %xmm1, %xmm8
movss 0x20(%rcx), %xmm0
movaps %xmm0, %xmm3
mulss %xmm8, %xmm3
movss 0x24(%rcx), %xmm2
mulss %xmm2, %xmm8
movss 0xf0(%rbx), %xmm4
movss 0xf4(%rbx), %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 0xa99d
movl 0xc(%rcx), %edx
testb $0x10, %dl
jne 0xa99d
xorl %esi, %esi
btl $0x17, %edx
setae %sil
leal 0x3(%rsi,%rsi), %edx
movss 0x50(%rcx), %xmm1
movq 0x45813(%rip), %rsi     # 0x50480
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 0xa99d
leaq 0x2cf48(%rip), %rdi     # 0x37bfd
leaq 0x2b9b1(%rip), %rsi     # 0x3666d
leaq 0x2cf6e(%rip), %rcx     # 0x37c31
movl $0xbf6, %edx            # imm = 0xBF6
callq 0x7140
leaq 0x2bb03(%rip), %rdi     # 0x367d7
leaq 0x2b992(%rip), %rsi     # 0x3666d
leaq 0x2bade(%rip), %rcx     # 0x367c0
movl $0x70c, %edx            # imm = 0x70C
callq 0x7140
leaq 0x2bab6(%rip), %rdi     # 0x367a9
leaq 0x2b973(%rip), %rsi     # 0x3666d
leaq 0x2babf(%rip), %rcx     # 0x367c0
movl $0x70b, %edx            # imm = 0x70B
callq 0x7140
leaq 0x2bafe(%rip), %rdi     # 0x36810
leaq 0x2b954(%rip), %rsi     # 0x3666d
leaq 0x2baa0(%rip), %rcx     # 0x367c0
movl $0x70d, %edx            # imm = 0x70D
callq 0x7140
leaq 0x2bafa(%rip), %rdi     # 0x3682b
leaq 0x2b935(%rip), %rsi     # 0x3666d
leaq 0x2ba81(%rip), %rcx     # 0x367c0
movl $0x70e, %edx            # imm = 0x70E
callq 0x7140
leaq 0x2bafc(%rip), %rdi     # 0x3684c
leaq 0x2b916(%rip), %rsi     # 0x3666d
leaq 0x2ba62(%rip), %rcx     # 0x367c0
movl $0x70f, %edx            # imm = 0x70F
callq 0x7140
leaq 0x2bb01(%rip), %rdi     # 0x36870
leaq 0x2b8f7(%rip), %rsi     # 0x3666d
leaq 0x2ba43(%rip), %rcx     # 0x367c0
movl $0x717, %edx            # imm = 0x717
callq 0x7140