LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircle(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

    const float a_max = IM_PI*2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(centre, radius, 0.0f, a_max, num_segments);
    PathStroke(col, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x40910
jmp 0x40971
movq -0x28(%rbp), %rdi
cvtsi2ssl -0x1c(%rbp), %xmm1
movss 0x1a6f7(%rip), %xmm0    # 0x5b018
subss %xmm0, %xmm1
movss 0x1a7e7(%rip), %xmm0    # 0x5b114
mulss %xmm1, %xmm0
cvtsi2ssl -0x1c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movl -0x1c(%rbp), %edx
xorps %xmm1, %xmm1
callq 0x3f990
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0x1, %edx
movss 0x1a6ac(%rip), %xmm0    # 0x5b018
callq 0x2eae0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircleFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

    const float a_max = IM_PI*2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(centre, radius, 0.0f, a_max, num_segments);
    PathFill(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x409b0
jmp 0x40a04
movq -0x28(%rbp), %rdi
cvtsi2ssl -0x1c(%rbp), %xmm1
movss 0x1a657(%rip), %xmm0    # 0x5b018
subss %xmm0, %xmm1
movss 0x1a747(%rip), %xmm0    # 0x5b114
mulss %xmm1, %xmm0
cvtsi2ssl -0x1c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movl -0x1c(%rbp), %edx
xorps %xmm1, %xmm1
callq 0x3f990
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2f3f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierCurve(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments) 
{ 
    if ((col >> 24) == 0)
        return;

    PathLineTo(pos0); 
    PathBezierCurveTo(cp0, cp1, pos1, num_segments); 
    PathStroke(col, false, thickness); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movss %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x40a4d
jmp 0x40a86
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2eab0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl 0x10(%rbp), %r8d
callq 0x3fad0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movss -0x30(%rbp), %xmm0
xorl %edx, %edx
callq 0x2eae0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddImage(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col)
{
    if ((col >> 24) == 0)
        return;

    // FIXME-OPT: This is wasting draw calls.
    const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back();
    if (push_texture_id)
        PushTextureID(user_texture_id);

    PrimReserve(6, 4);
    PrimRectUV(a, b, uv0, uv1, col);

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x10(%rbp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
jne 0x4175b
jmp 0x417f3
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x4c620
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x41799
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x60, %rdi
callq 0x4c250
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x417b4
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3d2c0
movq -0x40(%rbp), %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x3d830
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
callq 0x3da50
testb $0x1, -0x31(%rbp)
je 0x417f3
movq -0x40(%rbp), %rdi
callq 0x3d300
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawData::ScaleClipRects(ImVec2 const&)
void ImDrawData::ScaleClipRects(const ImVec2& scale)
{
    for (int i = 0; i < CmdListsCount; i++)
    {
        ImDrawList* cmd_list = CmdLists[i];
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i];
            cmd->ClipRect = ImVec4(cmd->ClipRect.x * scale.x, cmd->ClipRect.y * scale.y, cmd->ClipRect.z * scale.x, cmd->ClipRect.w * scale.y);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x48(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x41a7a
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x41a6a
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x4c6d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
mulss (%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm1
movq -0x30(%rbp), %rax
movss 0xc(%rax), %xmm2
movq -0x10(%rbp), %rax
mulss (%rax), %xmm2
movq -0x30(%rbp), %rax
movss 0x10(%rax), %xmm3
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm3
leaq -0x40(%rbp), %rdi
callq 0x2d2b0
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x4(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x419da
jmp 0x41a6c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x419af
addq $0x50, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontConfig::ImFontConfig()
ImFontConfig::ImFontConfig()
{
    FontData = NULL;
    FontDataSize = 0;
    FontDataOwnedByAtlas = true;
    FontNo = 0;
    SizePixels = 0.0f;
    OversampleH = 3;
    OversampleV = 1;
    PixelSnapH = false;
    GlyphExtraSpacing = ImVec2(0.0f, 0.0f);
    GlyphRanges = NULL;
    MergeMode = false;
    MergeGlyphCenterV = false;
    DstFont = NULL;
    memset(Name, 0, sizeof(Name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x24, %rdi
callq 0x2d230
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movb $0x1, 0xc(%rax)
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movl $0x3, 0x18(%rax)
movl $0x1, 0x1c(%rax)
movb $0x0, 0x20(%rax)
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x24(%rdi)
movq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movb $0x0, 0x39(%rdi)
movq $0x0, 0x60(%rdi)
addq $0x3a, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ImFontAtlas()
ImFontAtlas::ImFontAtlas()
{
    TexID = NULL;
    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
    TexWidth = TexHeight = TexDesiredWidth = 0;
    TexUvWhitePixel = ImVec2(0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x24, %rdi
callq 0x2d230
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x303b0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4c730
jmp 0x41b61
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x18(%rax)
leaq -0x1c(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
jmp 0x41ba2
movq -0x30(%rbp), %rax
movq -0x1c(%rbp), %rcx
movq %rcx, 0x24(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x41bd7
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4c760
movq -0x38(%rbp), %rdi
callq 0x306a0
movq -0x10(%rbp), %rdi
callq 0x74f0
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearInputData()
void    ImFontAtlas::ClearInputData()
{
    for (int i = 0; i < ConfigData.Size; i++)
        if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
        {
            ImGui::MemFree(ConfigData[i].FontData);
            ConfigData[i].FontData = NULL;
        }

    // When clearing this we lose access to the font name and other information used to build the font.
    for (int i = 0; i < Fonts.Size; i++)
        if (Fonts[i]->ConfigData >= ConfigData.Data && Fonts[i]->ConfigData < ConfigData.Data + ConfigData.Size)
        {
            Fonts[i]->ConfigData = NULL;
            Fonts[i]->ConfigDataCount = 0;
        }
    ConfigData.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x41d0f
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0x4c7a0
cmpq $0x0, (%rax)
je 0x41d02
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0x4c7a0
testb $0x1, 0xc(%rax)
je 0x41d02
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0x4c7a0
movq (%rax), %rdi
callq 0xa760
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0x4c7a0
movq $0x0, (%rax)
jmp 0x41d04
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41c9b
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x41dbb
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %esi
callq 0x2e330
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq 0x48(%rcx), %rax
jb 0x41dab
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %esi
callq 0x2e330
movq -0x18(%rbp), %rdx
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x48(%rdx), %rcx
movslq 0x40(%rdx), %rdx
imulq $0x68, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x41dab
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %esi
callq 0x2e330
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rdi
movl -0x10(%rbp), %esi
callq 0x2e330
movq (%rax), %rax
movl $0x0, 0x20(%rax)
jmp 0x41dad
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x41d16
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x4c800
addq $0x20, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearTexData()
void    ImFontAtlas::ClearTexData()
{
    if (TexPixelsAlpha8)
        ImGui::MemFree(TexPixelsAlpha8);
    if (TexPixelsRGBA32)
        ImGui::MemFree(TexPixelsRGBA32);
    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x41df8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa760
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x41e10
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa760
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearFonts()
void    ImFontAtlas::ClearFonts()
{
    for (int i = 0; i < Fonts.Size; i++)
    {
        Fonts[i]->~ImFont();
        ImGui::MemFree(Fonts[i]);
    }
    Fonts.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x41e92
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0x2e330
movq (%rax), %rdi
callq 0x45bb0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0x2e330
movq (%rax), %rdi
callq 0xa760
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41e4b
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2e6b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontDefault(ImFontConfig const*)
ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
{
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    if (!font_cfg_template)
    {
        font_cfg.OversampleH = font_cfg.OversampleV = 1;
        font_cfg.PixelSnapH = true;
    }
    if (font_cfg.Name[0] == '\0') strcpy(font_cfg.Name, "<default>");

    const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85();
    ImFont* font = AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, 13.0f, &font_cfg, GetGlyphRangesDefault());
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x41f99
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x68, %edx
callq 0x7080
jmp 0x41fa2
leaq -0x78(%rbp), %rdi
callq 0x41a80
cmpq $0x0, -0x10(%rbp)
jne 0x41fbb
movl $0x1, -0x5c(%rbp)
movl $0x1, -0x60(%rbp)
movb $0x1, -0x58(%rbp)
movsbl -0x3e(%rbp), %eax
cmpl $0x0, %eax
jne 0x41fd8
leaq -0x78(%rbp), %rdi
addq $0x3a, %rdi
leaq 0x22753(%rip), %rsi     # 0x64726
callq 0x7350
callq 0x433c0
movq -0x90(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x43460
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq %rax, %rcx
movss 0x1e5bf(%rip), %xmm0    # 0x605d0
leaq -0x78(%rbp), %rdx
callq 0x433d0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::GetTexDataAsRGBA32(unsigned char**, int*, int*, int*)
void    ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    // Convert to RGBA32 format on demand
    // Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp
    if (!TexPixelsRGBA32)
    {
        unsigned char* pixels;
        GetTexDataAsAlpha8(&pixels, NULL, NULL);
        TexPixelsRGBA32 = (unsigned int*)ImGui::MemAlloc((size_t)(TexWidth * TexHeight * 4));
        const unsigned char* src = pixels;
        unsigned int* dst = TexPixelsRGBA32;
        for (int n = TexWidth * TexHeight; n > 0; n--)
            *dst++ = ((unsigned int)(*src++) << 24) | 0x00FFFFFF;
    }

    *out_pixels = (unsigned char*)TexPixelsRGBA32;
    if (out_width) *out_width = TexWidth;
    if (out_height) *out_height = TexHeight;
    if (out_bytes_per_pixel) *out_bytes_per_pixel = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x4320e
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x41eb0
movq -0x50(%rbp), %rcx
movl 0x18(%rcx), %eax
imull 0x1c(%rcx), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x93d0
movq -0x50(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rcx), %rax
movq %rax, -0x40(%rbp)
movl 0x18(%rcx), %eax
imull 0x1c(%rcx), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jle 0x4320c
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movzbl (%rax), %ecx
shll $0x18, %ecx
orl $0xffffff, %ecx         # imm = 0xFFFFFF
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x431cf
jmp 0x4320e
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x43231
movq -0x50(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x43245
movq -0x50(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x43256
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFont(ImFontConfig const*)
ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg)
{
    IM_ASSERT(font_cfg->FontData != NULL && font_cfg->FontDataSize > 0);
    IM_ASSERT(font_cfg->SizePixels > 0.0f);

    // Create new font
    if (!font_cfg->MergeMode)
    {
        ImFont* font = (ImFont*)ImGui::MemAlloc(sizeof(ImFont));
        new (font) ImFont();
        Fonts.push_back(font);
    }

    ConfigData.push_back(*font_cfg);
    ImFontConfig& new_font_cfg = ConfigData.back();
    new_font_cfg.DstFont = Fonts.back();
    if (!new_font_cfg.FontDataOwnedByAtlas)
    {
        new_font_cfg.FontData = ImGui::MemAlloc(new_font_cfg.FontDataSize);
        new_font_cfg.FontDataOwnedByAtlas = true;
        memcpy(new_font_cfg.FontData, font_cfg->FontData, (size_t)new_font_cfg.FontDataSize);
    }

    // Invalidate texture
    ClearTexData();
    return Fonts.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x43295
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setg %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4329e
jmp 0x432a0
jmp 0x432bf
leaq 0x213f5(%rip), %rdi     # 0x6469c
leaq 0x21248(%rip), %rsi     # 0x644f6
movl $0x41b, %edx            # imm = 0x41B
leaq 0x2141d(%rip), %rcx     # 0x646d7
callq 0x7160
movq -0x10(%rbp), %rax
movss 0x14(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x432d2
jmp 0x432f1
leaq 0x21431(%rip), %rdi     # 0x6470a
leaq 0x21216(%rip), %rsi     # 0x644f6
movl $0x41c, %edx            # imm = 0x41C
leaq 0x213eb(%rip), %rcx     # 0x646d7
callq 0x7160
movq -0x10(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x43323
movl $0x78, %edi
callq 0x93d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45a50
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2f830
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0x4c870
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x4c8e0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x2f900
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0xc(%rax)
jne 0x433a1
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x93d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x7080
movq -0x30(%rbp), %rdi
callq 0x41dd0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x2f900
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(char const*, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4;
    void* compressed_ttf = ImGui::MemAlloc(compressed_ttf_size);
    Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned int*)compressed_ttf);
    ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges);
    ImGui::MemFree(compressed_ttf);
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7330
addl $0x4, %eax
movl $0x5, %ecx
cltd
idivl %ecx
shll $0x2, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0x93d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x43a70
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x436e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa760
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromFileTTF(char const*, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    int data_size = 0;
    void* data = ImLoadFileToMemory(filename, "rb", &data_size, 0);
    if (!data)
    {
        IM_ASSERT(0); // Could not load file.
        return NULL;
    }
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    if (font_cfg.Name[0] == '\0')
    {
        // Store a short copy of filename into into the font name for convenience
        const char* p;
        for (p = filename + strlen(filename); p > filename && p[-1] != '/' && p[-1] != '\\'; p--) {}
        snprintf(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s", p);
    }
    return AddFontFromMemoryTTF(data, data_size, size_pixels, &font_cfg, glyph_ranges);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x191f5(%rip), %rsi     # 0x5c6b2
leaq -0x2c(%rbp), %rdx
xorl %ecx, %ecx
callq 0xa5c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x434f2
leaq 0x193b1(%rip), %rdi     # 0x5c88b
leaq 0x21015(%rip), %rsi     # 0x644f6
movl $0x452, %edx            # imm = 0x452
leaq 0x21243(%rip), %rcx     # 0x64730
callq 0x7160
cmpq $0x0, -0x20(%rbp)
je 0x43510
movq -0x20(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x68, %edx
callq 0x7080
jmp 0x4351c
leaq -0xa0(%rbp), %rdi
callq 0x41a80
movsbl -0x66(%rbp), %eax
cmpl $0x0, %eax
jne 0x435dc
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7330
movq %rax, %rcx
movq -0xb8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0xb9(%rbp)
jbe 0x43595
movq -0xa8(%rbp), %rax
movsbl -0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0xb9(%rbp)
je 0x43595
movq -0xa8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
setne %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x435a1
jmp 0x435b7
jmp 0x435a3
movq -0xa8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x43551
leaq -0xa0(%rbp), %rdi
addq $0x3a, %rdi
movq -0xa8(%rbp), %rcx
movl $0x20, %esi
leaq 0x1cc70(%rip), %rdx     # 0x60245
movb $0x0, %al
callq 0x7400
movq -0xb0(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movss -0x14(%rbp), %xmm0
movq -0x28(%rbp), %r8
leaq -0xa0(%rbp), %rcx
callq 0x43610
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryTTF(void*, int, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    IM_ASSERT(font_cfg.FontData == NULL);
    font_cfg.FontData = ttf_data;
    font_cfg.FontDataSize = ttf_size;
    font_cfg.SizePixels = size_pixels;
    if (glyph_ranges)
        font_cfg.GlyphRanges = glyph_ranges;
    return AddFont(&font_cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4365c
movq -0x20(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x68, %edx
callq 0x7080
jmp 0x43668
leaq -0x90(%rbp), %rdi
callq 0x41a80
cmpq $0x0, -0x90(%rbp)
jne 0x43674
jmp 0x43693
leaq 0x21119(%rip), %rdi     # 0x64794
leaq 0x20e74(%rip), %rsi     # 0x644f6
movl $0x464, %edx            # imm = 0x464
leaq 0x21122(%rip), %rcx     # 0x647b0
callq 0x7160
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x88(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x436c0
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x98(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x43260
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryCompressedTTF(void const*, int, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    const unsigned int buf_decompressed_size = stb_decompress_length((unsigned char*)compressed_ttf_data);
    unsigned char* buf_decompressed_data = (unsigned char *)ImGui::MemAlloc(buf_decompressed_size);
    stb_decompress(buf_decompressed_data, (unsigned char*)compressed_ttf_data, (unsigned int)compressed_ttf_size);

    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    IM_ASSERT(font_cfg.FontData == NULL);
    font_cfg.FontDataOwnedByAtlas = true;
    return AddFontFromMemoryTTF(buf_decompressed_data, (int)buf_decompressed_size, size_pixels, font_cfg_template, glyph_ranges);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x437c0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0x93d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x43800
cmpq $0x0, -0x20(%rbp)
je 0x43756
movq -0x20(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x68, %edx
callq 0x7080
jmp 0x43762
leaq -0xa0(%rbp), %rdi
callq 0x41a80
cmpq $0x0, -0xa0(%rbp)
jne 0x4376e
jmp 0x4378d
leaq 0x2101f(%rip), %rdi     # 0x64794
leaq 0x20d7a(%rip), %rsi     # 0x644f6
movl $0x474, %edx            # imm = 0x474
leaq 0x2108d(%rip), %rcx     # 0x64815
callq 0x7160
movq -0xa8(%rbp), %rdi
movb $0x1, -0x94(%rbp)
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movss -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x43610
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt_PackSetOversampling(stbtt_pack_context*, unsigned int, unsigned int)
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
{
   STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
   STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
   if (h_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->h_oversample = h_oversample;
   if (v_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->v_oversample = v_oversample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0xc(%rbp)
ja 0x4477a
jmp 0x44799
leaq 0x202c1(%rip), %rdi     # 0x64a42
leaq 0x202cc(%rip), %rsi     # 0x64a54
movl $0xa79, %edx            # imm = 0xA79
leaq 0x202d7(%rip), %rcx     # 0x64a6b
callq 0x7160
cmpl $0x8, -0x10(%rbp)
ja 0x447a1
jmp 0x447c0
leaq 0x20314(%rip), %rdi     # 0x64abc
leaq 0x202a5(%rip), %rsi     # 0x64a54
movl $0xa7a, %edx            # imm = 0xA7A
leaq 0x202b0(%rip), %rcx     # 0x64a6b
callq 0x7160
cmpl $0x8, -0xc(%rbp)
ja 0x447d0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x8, -0x10(%rbp)
ja 0x447e0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFont::FindGlyph(unsigned short) const
const ImFont::Glyph* ImFont::FindGlyph(unsigned short c) const
{
    if (c < IndexLookup.Size)
    {
        const int i = IndexLookup[c];
        if (i != -1)
            return &Glyphs[i];
    }
    return FallbackGlyph;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
cmpl 0x68(%rcx), %eax
jge 0x453d8
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movzwl -0x12(%rbp), %esi
callq 0x4ccf0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x453d6
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0x18(%rbp), %esi
callq 0x4cd50
movq %rax, -0x8(%rbp)
jmp 0x453e4
jmp 0x453d8
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFont::Clear()
void    ImFont::Clear()
{
    FontSize = 0.0f;
    DisplayOffset = ImVec2(0.0f, 1.0f);
    ConfigData = NULL;
    ConfigDataCount = 0;
    Ascent = Descent = 0.0f;
    ContainerAtlas = NULL;
    Glyphs.clear();
    FallbackGlyph = NULL;
    FallbackXAdvance = 0.0f;
    IndexXAdvance.clear();
    IndexLookup.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
movss 0x154de(%rip), %xmm1    # 0x5b018
callq 0x2d280
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rdi)
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
callq 0x4cba0
movq -0x18(%rbp), %rdi
movq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x50(%rdi)
addq $0x58, %rdi
callq 0x4cbf0
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x3cb00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt__isfont(unsigned char const*)
static int stbtt__isfont(const stbtt_uint8 *font)
{
   // check the version number
   if (stbtt_tag4(font, '1',0,0,0))  return 1; // TrueType 1
   if (stbtt_tag(font, "typ1"))   return 1; // TrueType with type 1 font -- we don't support this!
   if (stbtt_tag(font, "OTTO"))   return 1; // OpenType with CFF
   if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x31, %eax
jne 0x46297
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x46297
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x46297
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x46297
movl $0x1, -0x4(%rbp)
jmp 0x46385
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x1e6ea(%rip), %ecx     # 0x6498f
cmpl %ecx, %eax
jne 0x462ee
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x1e6d8(%rip), %ecx     # 0x64990
cmpl %ecx, %eax
jne 0x462ee
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x1e6c6(%rip), %ecx     # 0x64991
cmpl %ecx, %eax
jne 0x462ee
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x1e6b4(%rip), %ecx     # 0x64992
cmpl %ecx, %eax
jne 0x462ee
movl $0x1, -0x4(%rbp)
jmp 0x46385
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x1e698(%rip), %ecx     # 0x64994
cmpl %ecx, %eax
jne 0x46342
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x1e686(%rip), %ecx     # 0x64995
cmpl %ecx, %eax
jne 0x46342
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x1e674(%rip), %ecx     # 0x64996
cmpl %ecx, %eax
jne 0x46342
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x1e662(%rip), %ecx     # 0x64997
cmpl %ecx, %eax
jne 0x46342
movl $0x1, -0x4(%rbp)
jmp 0x46385
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4637e
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x4637e
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x4637e
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x4637e
movl $0x1, -0x4(%rbp)
jmp 0x46385
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/stb_rect_pack.h
// Function: rect_height_compare(void const*, void const*)
static int rect_height_compare(const void *a, const void *b)
{
   stbrp_rect *p = (stbrp_rect *) a;
   stbrp_rect *q = (stbrp_rect *) b;
   if (p->h > q->h)
      return -1;
   if (p->h < q->h)
      return  1;
   return (p->w > q->w) ? -1 : (p->w < q->w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jle 0x46719
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46777
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jge 0x46736
movl $0x1, -0x4(%rbp)
jmp 0x46777
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jle 0x46754
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x46771
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt_GetGlyphBox(stbtt_fontinfo const*, int, int*, int*, int*, int*)
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   int g = stbtt__GetGlyfOffset(info, glyph_index);
   if (g < 0) return 0;

   if (x0) *x0 = ttSHORT(info->data + g + 2);
   if (y0) *y0 = ttSHORT(info->data + g + 4);
   if (x1) *x1 = ttSHORT(info->data + g + 6);
   if (y1) *y1 = ttSHORT(info->data + g + 8);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x47670
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x475c0
movl $0x0, -0x4(%rbp)
jmp 0x47667
cmpq $0x0, -0x20(%rbp)
je 0x475e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x2, %rdi
callq 0x47560
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x47610
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x47560
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x47638
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x6, %rdi
callq 0x47560
movswl %ax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x47660
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x47560
movswl %ax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt_Rasterize(stbtt__bitmap*, float, stbtt_vertex*, int, float, float, float, float, int, int, int, void*)
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
{
   float scale = scale_x > scale_y ? scale_y : scale_x;
   int winding_count, *winding_lengths;
   stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
   if (windings) {
      stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
      STBTT_free(winding_lengths, userdata);
      STBTT_free(windings, userdata);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movl %r9d, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x49132
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
jmp 0x4913c
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movss -0xc(%rbp), %xmm0
divss -0x3c(%rbp), %xmm0
movq 0x10(%rbp), %r8
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x49350
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x491c6
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %ecx
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movl -0x38(%rbp), %r10d
movq 0x10(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x496a0
movq -0x48(%rbp), %rdi
callq 0xa760
movq -0x50(%rbp), %rdi
callq 0xa760
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt__new_active(stbtt__hheap*, stbtt__edge*, int, float, void*)
static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
{
   stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
   float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
   //STBTT_assert(e->y0 <= start_point);
   if (!z) return z;
   z->fdx = dxdy;
   z->fdy = (1/dxdy);
   z->fx = e->x0 + dxdy * (start_point - e->y0);
   z->fx -= off_x;
   z->direction = e->invert ? 1.0f : -1.0f;
   z->sy = e->y0;
   z->ey = e->y1;
   z->next = 0;
   return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x20, %esi
callq 0x4b1f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a5c2
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a69e
movss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss 0x10a40(%rip), %xmm0    # 0x5b018
divss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x34(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
cvtsi2ssl -0x1c(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movss 0x109e0(%rip), %xmm0    # 0x5b018
movss 0x10a3c(%rip), %xmm1    # 0x5b07c
movss %xmm1, -0x3c(%rbp)
cmpl $0x0, %eax
movss %xmm0, -0x38(%rbp)
jne 0x4a659
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: stb__match(unsigned char*, unsigned int)
static void stb__match(unsigned char *data, unsigned int length)
{
    // INVERSE of memmove... write each byte before copying the next...
    IM_ASSERT (stb__dout + length <= stb__barrier);
    if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
    if (data < stb__barrier4) { stb__dout = stb__barrier+1; return; }
    while (length--) *stb__dout++ = *data++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x380da(%rip), %rax     # 0x83de0
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0x380bd(%rip), %rax     # 0x83dd0
ja 0x4bd17
jmp 0x4bd36
leaq 0x19301(%rip), %rdi     # 0x6501f
leaq 0x187d1(%rip), %rsi     # 0x644f6
movl $0x7e3, %edx            # imm = 0x7E3
leaq 0x19311(%rip), %rcx     # 0x65042
callq 0x7160
movq 0x380a3(%rip), %rax     # 0x83de0
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0x38086(%rip), %rax     # 0x83dd0
jbe 0x4bd64
movl -0xc(%rbp), %ecx
movq 0x3808a(%rip), %rax     # 0x83de0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x3807e(%rip)     # 0x83de0
jmp 0x4bdc1
movq -0x8(%rbp), %rax
cmpq 0x38069(%rip), %rax     # 0x83dd8
jae 0x4bd85
movq 0x38058(%rip), %rax     # 0x83dd0
addq $0x1, %rax
movq %rax, 0x3805d(%rip)     # 0x83de0
jmp 0x4bdc1
jmp 0x4bd87
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x4bdc1
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq 0x38031(%rip), %rax     # 0x83de0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x38023(%rip)     # 0x83de0
movb %cl, (%rax)
jmp 0x4bd87
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: stb__lit(unsigned char*, unsigned int)
static void stb__lit(unsigned char *data, unsigned int length)
{
    IM_ASSERT (stb__dout + length <= stb__barrier);
    if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
    if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
    memcpy(stb__dout, data, length);
    stb__dout += length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x37ffa(%rip), %rax     # 0x83de0
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0x37fdd(%rip), %rax     # 0x83dd0
ja 0x4bdf7
jmp 0x4be16
leaq 0x19221(%rip), %rdi     # 0x6501f
leaq 0x186f1(%rip), %rsi     # 0x644f6
movl $0x7eb, %edx            # imm = 0x7EB
leaq 0x19260(%rip), %rcx     # 0x65071
callq 0x7160
movq 0x37fc3(%rip), %rax     # 0x83de0
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0x37fa6(%rip), %rax     # 0x83dd0
jbe 0x4be44
movl -0xc(%rbp), %ecx
movq 0x37faa(%rip), %rax     # 0x83de0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x37f9e(%rip)     # 0x83de0
jmp 0x4be90
movq -0x8(%rbp), %rax
cmpq 0x37f71(%rip), %rax     # 0x83dc0
jae 0x4be65
movq 0x37f78(%rip), %rax     # 0x83dd0
addq $0x1, %rax
movq %rax, 0x37f7d(%rip)     # 0x83de0
jmp 0x4be90
movq 0x37f74(%rip), %rdi     # 0x83de0
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x7080
movl -0xc(%rbp), %ecx
movq 0x37f5c(%rip), %rax     # 0x83de0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x37f50(%rip)     # 0x83de0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui_impl_sdl.cpp
// Function: ImGui_ImplSdl_InvalidateDeviceObjects()
void ImGui_ImplSdl_InvalidateDeviceObjects()
{
    if (g_VboHandle) glDeleteBuffers(1, &g_VboHandle);
    if (g_ElementsHandle) glDeleteBuffers(1, &g_ElementsHandle);

    glDetachShader(g_ShaderHandle, g_VertHandle);
    glDeleteShader(g_VertHandle);
    g_VertHandle = 0;

    glDetachShader(g_ShaderHandle, g_FragHandle);
    glDeleteShader(g_FragHandle);
    g_FragHandle = 0;

    glDeleteProgram(g_ShaderHandle);
    g_ShaderHandle = 0;

    if (g_FontTexture)
    {
        glDeleteTextures(1, &g_FontTexture);
        ImGui::GetIO().Fonts->TexID = 0;
        g_FontTexture = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x35f49(%rip)     # 0x83df4
je 0x4debe
movl $0x1, %edi
leaq 0x35f3b(%rip), %rsi     # 0x83df4
callq 0x7890
cmpl $0x0, 0x35f3f(%rip)     # 0x83e04
je 0x4ded8
movl $0x1, %edi
leaq 0x35f31(%rip), %rsi     # 0x83e04
callq 0x7890
movl 0x35f0a(%rip), %edi     # 0x83de8
movl 0x35f2c(%rip), %esi     # 0x83e10
callq 0x73e0
movl 0x35f21(%rip), %edi     # 0x83e10
callq 0x7870
movl $0x0, 0x35f12(%rip)     # 0x83e10
movl 0x35ee4(%rip), %edi     # 0x83de8
movl 0x35f0a(%rip), %esi     # 0x83e14
callq 0x73e0
movl 0x35eff(%rip), %edi     # 0x83e14
callq 0x7870
movl $0x0, 0x35ef0(%rip)     # 0x83e14
movl 0x35ebe(%rip), %edi     # 0x83de8
callq 0x7650
movl $0x0, 0x35eaf(%rip)     # 0x83de8
cmpl $0x0, 0x35ed8(%rip)     # 0x83e18
je 0x4df70
movl $0x1, %edi
leaq 0x35eca(%rip), %rsi     # 0x83e18
callq 0x77e0
callq 0xca90
movq 0x88(%rax), %rax
movq $0x0, (%rax)
movl $0x0, 0x35ea8(%rip)     # 0x83e18
popq %rbp
retq
nopw %cs:(%rax,%rax)