// File: donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFont::RenderText(float, ImVec2, unsigned int, ImVec4 const&, char const*, char const*, ImDrawList*, float, bool) const
void ImFont::RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, ImDrawList* draw_list, float wrap_width, bool cpu_fine_clip) const
{
    if (!text_end)
        text_end = text_begin + strlen(text_begin);

    // Align to be pixel perfect
    pos.x = (float)(int)pos.x + DisplayOffset.x;
    pos.y = (float)(int)pos.y + DisplayOffset.y;
    float x = pos.x;
    float y = pos.y;
    if (y > clip_rect.w)
        return;

    const float scale = size / FontSize;
    const float line_height = FontSize * scale;
    const bool word_wrap_enabled = (wrap_width > 0.0f);
    const char* word_wrap_eol = NULL;

    ImDrawVert* vtx_write = draw_list->_VtxWritePtr;
    ImDrawIdx* idx_write = draw_list->_IdxWritePtr;
    unsigned int vtx_current_idx = draw_list->_VtxCurrentIdx;

    const char* s = text_begin;
    if (!word_wrap_enabled && y + line_height < clip_rect.y)
        while (s < text_end && *s != '\n')  // Fast-forward to next line
            s++;
    while (s < text_end)
    {
        if (word_wrap_enabled)
        {
            // Calculate how far we can render. Requires two passes on the string data but keeps the code simple and not intrusive for what's essentially an uncommon feature.
            if (!word_wrap_eol)
            {
                word_wrap_eol = CalcWordWrapPositionA(scale, s, text_end, wrap_width - (x - pos.x));
                if (word_wrap_eol == s) // Wrap_width is too small to fit anything. Force displaying 1 character to minimize the height discontinuity.
                    word_wrap_eol++;    // +1 may not be a character start point in UTF-8 but it's ok because we use s >= word_wrap_eol below
            }

            if (s >= word_wrap_eol)
            {
                x = pos.x;
                y += line_height;
                word_wrap_eol = NULL;

                // Wrapping skips upcoming blanks
                while (s < text_end)
                {
                    const char c = *s;
                    if (ImCharIsSpace(c)) { s++; } else if (c == '\n') { s++; break; } else { break; }
                }
                continue;
            }
        }

        // Decode and advance source
        unsigned int c = (unsigned int)*s;
        if (c < 0x80)
        {
            s += 1;
        }
        else
        {
            s += ImTextCharFromUtf8(&c, s, text_end);
            if (c == 0)
                break;
        }

        if (c < 32)
        {
            if (c == '\n')
            {
                x = pos.x;
                y += line_height;

                if (y > clip_rect.w)
                    break;
                if (!word_wrap_enabled && y + line_height < clip_rect.y)
                    while (s < text_end && *s != '\n')  // Fast-forward to next line
                        s++;
                continue;
            }
            if (c == '\r')
                continue;
        }

        float char_width = 0.0f;
        if (const Glyph* glyph = FindGlyph((unsigned short)c))
        {
            char_width = glyph->XAdvance * scale;

            // Clipping on Y is more likely
            if (c != ' ' && c != '\t')
            {
                // We don't do a second finer clipping test on the Y axis (TODO: do some measurement see if it is worth it, probably not)
                float y1 = (float)(y + glyph->Y0 * scale);
                float y2 = (float)(y + glyph->Y1 * scale);

                float x1 = (float)(x + glyph->X0 * scale);
                float x2 = (float)(x + glyph->X1 * scale);
                if (x1 <= clip_rect.z && x2 >= clip_rect.x)
                {
                    // Render a character
                    float u1 = glyph->U0;
                    float v1 = glyph->V0;
                    float u2 = glyph->U1;
                    float v2 = glyph->V1;

                    // CPU side clipping used to fit text in their frame when the frame is too small. Only does clipping for axis aligned quads.
                    if (cpu_fine_clip)
                    {
                        if (x1 < clip_rect.x)
                        {
                            u1 = u1 + (1.0f - (x2 - clip_rect.x) / (x2 - x1)) * (u2 - u1);
                            x1 = clip_rect.x;
                        }
                        if (y1 < clip_rect.y)
                        {
                            v1 = v1 + (1.0f - (y2 - clip_rect.y) / (y2 - y1)) * (v2 - v1);
                            y1 = clip_rect.y;
                        }
                        if (x2 > clip_rect.z)
                        {
                            u2 = u1 + ((clip_rect.z - x1) / (x2 - x1)) * (u2 - u1);
                            x2 = clip_rect.z;
                        }
                        if (y2 > clip_rect.w)
                        {
                            v2 = v1 + ((clip_rect.w - y1) / (y2 - y1)) * (v2 - v1);
                            y2 = clip_rect.w;
                        }
                        if (y1 >= y2)
                        {
                            x += char_width;
                            continue;
                        }
                    }

                    // NB: we are not calling PrimRectUV() here because non-inlined causes too much overhead in a debug build.
                    // inlined:
                    {
                        idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+2);
                        idx_write[3] = (ImDrawIdx)(vtx_current_idx); idx_write[4] = (ImDrawIdx)(vtx_current_idx+2); idx_write[5] = (ImDrawIdx)(vtx_current_idx+3);
                        vtx_write[0].pos.x = x1; vtx_write[0].pos.y = y1; vtx_write[0].col = col; vtx_write[0].uv.x = u1; vtx_write[0].uv.y = v1;
                        vtx_write[1].pos.x = x2; vtx_write[1].pos.y = y1; vtx_write[1].col = col; vtx_write[1].uv.x = u2; vtx_write[1].uv.y = v1;
                        vtx_write[2].pos.x = x2; vtx_write[2].pos.y = y2; vtx_write[2].col = col; vtx_write[2].uv.x = u2; vtx_write[2].uv.y = v2;
                        vtx_write[3].pos.x = x1; vtx_write[3].pos.y = y2; vtx_write[3].col = col; vtx_write[3].uv.x = u1; vtx_write[3].uv.y = v2;
                        vtx_write += 4;
                        vtx_current_idx += 4;
                        idx_write += 6;
                    }
                }
            }
        }

        x += char_width;
    }

    draw_list->_VtxWritePtr = vtx_write;
    draw_list->_VtxCurrentIdx = vtx_current_idx;
    draw_list->_IdxWritePtr = idx_write;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb 0x10(%rbp), %al
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movss %xmm2, -0x3c(%rbp)
andb $0x1, %al
movb %al, -0x3d(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x40de0
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7330
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0xc0(%rbp), %rax
cvttss2si -0x8(%rbp), %ecx
cvtsi2ss %ecx, %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
cvttss2si -0x4(%rbp), %ecx
cvtsi2ss %ecx, %xmm0
addss 0xc(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomiss 0xc(%rax), %xmm0
jbe 0x40e35
jmp 0x41689
movq -0xc0(%rbp), %rax
movss -0x14(%rbp), %xmm0
divss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movss (%rax), %xmm0
mulss -0x4c(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movss -0x3c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x51(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x40efe
movss -0x48(%rbp), %xmm1
addss -0x50(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x40efe
jmp 0x40ebd
movq -0x80(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0xc9(%rbp)
jae 0x40ee2
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x40eee
jmp 0x40efc
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x40ebd
jmp 0x40efe
jmp 0x40f00
movq -0x80(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x41667
testb $0x1, -0x51(%rbp)
je 0x40fed
cmpq $0x0, -0x60(%rbp)
jne 0x40f67
movq -0xc0(%rbp), %rdi
movss -0x4c(%rbp), %xmm0
movq -0x80(%rbp), %rsi
movq -0x30(%rbp), %rdx
movss -0x3c(%rbp), %xmm1
movss -0x44(%rbp), %xmm2
subss -0x8(%rbp), %xmm2
subss %xmm2, %xmm1
callq 0x45c30
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x80(%rbp), %rax
jne 0x40f65
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x40f67
movq -0x80(%rbp), %rax
cmpq -0x60(%rbp), %rax
jb 0x40feb
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x50(%rbp), %xmm0
addss -0x48(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x40fe6
movq -0x80(%rbp), %rax
movb (%rax), %al
movb %al, -0x81(%rbp)
movsbl -0x81(%rbp), %edi
callq 0x45ec0
testb $0x1, %al
jne 0x40fba
jmp 0x40fc8
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x40fe4
movsbl -0x81(%rbp), %eax
cmpl $0xa, %eax
jne 0x40fe2
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x40fe6
jmp 0x40fe6
jmp 0x40f92
jmp 0x40f00
jmp 0x40fed
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x88(%rbp)
cmpl $0x80, -0x88(%rbp)
jae 0x41014
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x41048
movq -0x80(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x9850
movl %eax, %ecx
movq -0x80(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x88(%rbp)
jne 0x41046
jmp 0x41667
jmp 0x41048
cmpl $0x20, -0x88(%rbp)
jae 0x41105
cmpl $0xa, -0x88(%rbp)
jne 0x410f5
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x50(%rbp), %xmm0
addss -0x48(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomiss 0xc(%rax), %xmm0
jbe 0x4108f
jmp 0x41667
testb $0x1, -0x51(%rbp)
jne 0x410f0
movss -0x48(%rbp), %xmm1
addss -0x50(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x410f0
jmp 0x410af
movq -0x80(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0xca(%rbp)
jae 0x410d4
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0xca(%rbp)
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x410e0
jmp 0x410ee
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x410af
jmp 0x410f0
jmp 0x40f00
cmpl $0xd, -0x88(%rbp)
jne 0x41103
jmp 0x40f00
jmp 0x41105
movq -0xc0(%rbp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, -0x8c(%rbp)
movl -0x88(%rbp), %eax
movzwl %ax, %esi
callq 0x45380
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x41650
movq -0x98(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0x4c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
cmpl $0x20, -0x88(%rbp)
je 0x4164e
cmpl $0x9, -0x88(%rbp)
je 0x4164e
movss -0x48(%rbp), %xmm1
movq -0x98(%rbp), %rax
movss 0xc(%rax), %xmm0
movss -0x4c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x9c(%rbp)
movss -0x48(%rbp), %xmm1
movq -0x98(%rbp), %rax
movss 0x14(%rax), %xmm0
movss -0x4c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xa0(%rbp)
movss -0x44(%rbp), %xmm1
movq -0x98(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x4c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xa4(%rbp)
movss -0x44(%rbp), %xmm1
movq -0x98(%rbp), %rax
movss 0x10(%rax), %xmm0
movss -0x4c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xa8(%rbp)
movss -0xa4(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4164c
movss -0xa8(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomiss (%rax), %xmm0
jb 0x4164c
movq -0x98(%rbp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0xac(%rbp)
movq -0x98(%rbp), %rax
movss 0x1c(%rax), %xmm0
movss %xmm0, -0xb0(%rbp)
movq -0x98(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0xb4(%rbp)
movq -0x98(%rbp), %rax
movss 0x24(%rax), %xmm0
movss %xmm0, -0xb8(%rbp)
testb $0x1, -0x3d(%rbp)
je 0x41495
movss -0xa4(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4130b
movss -0xac(%rbp), %xmm1
movss -0xa8(%rbp), %xmm2
movq -0x20(%rbp), %rax
subss (%rax), %xmm2
movss -0xa8(%rbp), %xmm0
subss -0xa4(%rbp), %xmm0
divss %xmm0, %xmm2
movss 0x19d41(%rip), %xmm0    # 0x5b018
subss %xmm2, %xmm0
movss -0xb4(%rbp), %xmm2
subss -0xac(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xac(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0xa4(%rbp)
movss -0x9c(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4138b
movss -0xb0(%rbp), %xmm1
movss -0xa0(%rbp), %xmm2
movq -0x20(%rbp), %rax
subss 0x4(%rax), %xmm2
movss -0xa0(%rbp), %xmm0
subss -0x9c(%rbp), %xmm0
divss %xmm0, %xmm2
movss 0x19cc2(%rip), %xmm0    # 0x5b018
subss %xmm2, %xmm0
movss -0xb8(%rbp), %xmm2
subss -0xb0(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xb0(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x9c(%rbp)
movss -0xa8(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
jbe 0x413fb
movss -0xac(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0xa4(%rbp), %xmm0
movss -0xa8(%rbp), %xmm2
subss -0xa4(%rbp), %xmm2
divss %xmm2, %xmm0
movss -0xb4(%rbp), %xmm2
subss -0xac(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xb4(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0xa8(%rbp)
movss -0xa0(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomiss 0xc(%rax), %xmm0
jbe 0x4146b
movss -0xb0(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
subss -0x9c(%rbp), %xmm0
movss -0xa0(%rbp), %xmm2
subss -0x9c(%rbp), %xmm2
divss %xmm2, %xmm0
movss -0xb8(%rbp), %xmm2
subss -0xb0(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xb8(%rbp)
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0xa0(%rbp)
movss -0x9c(%rbp), %xmm0
ucomiss -0xa0(%rbp), %xmm0
jb 0x41493
movss -0x8c(%rbp), %xmm0
addss -0x44(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
jmp 0x40f00
jmp 0x41495
movl -0x74(%rbp), %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, (%rax)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x74(%rbp), %eax
addl $0x2, %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x74(%rbp), %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, 0x6(%rax)
movl -0x74(%rbp), %eax
addl $0x2, %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, 0x8(%rax)
movl -0x74(%rbp), %eax
addl $0x3, %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, 0xa(%rax)
movss -0xa4(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, (%rax)
movss -0x9c(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x4(%rax)
movl -0x18(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x10(%rax)
movss -0xac(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0xb0(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0xa8(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x9c(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x24(%rax)
movss -0xb4(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movss -0xb0(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0xa8(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0xa0(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x2c(%rax)
movl -0x18(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x38(%rax)
movss -0xb4(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x30(%rax)
movss -0xb8(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x34(%rax)
movss -0xa4(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movss -0xa0(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x40(%rax)
movl -0x18(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x4c(%rax)
movss -0xac(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x44(%rax)
movss -0xb8(%rbp), %xmm0
movq -0x68(%rbp), %rax
movss %xmm0, 0x48(%rax)
movq -0x68(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x68(%rbp)
movl -0x74(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x74(%rbp)
movq -0x70(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x70(%rbp)
jmp 0x4164e
jmp 0x41650
movss -0x8c(%rbp), %xmm0
addss -0x44(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
jmp 0x40f00
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x74(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x70(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)