LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SliderAngle(char const*, float*, float, float, char const*, int)
bool ImGui::SliderAngle(const char* label, float* v_rad, float v_degrees_min, float v_degrees_max, const char* format, ImGuiSliderFlags flags)
{
    if (format == NULL)
        format = "%.0f deg";
    float v_deg = (*v_rad) * 360.0f / (2 * IM_PI);
    bool value_changed = SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, format, flags);
    *v_rad = v_deg * (2 * IM_PI) / 360.0f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x144ab3
leaq 0x36095(%rip), %rax     # 0x17ab44
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x33b09(%rip), %xmm0    # 0x1785c8
mulss (%rax), %xmm0
movss 0x3ef39(%rip), %xmm1    # 0x183a04
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x28(%rbp), %rsi
callq 0x144910
andb $0x1, %al
movb %al, -0x29(%rbp)
movss 0x3ef05(%rip), %xmm0    # 0x183a04
mulss -0x28(%rbp), %xmm0
movss 0x33abc(%rip), %xmm1    # 0x1785c8
divss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SliderScalar(char const*, int, void*, void const*, void const*, char const*, float)
bool ImGui::SliderScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, float power)
{
    ImGuiSliderFlags slider_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        slider_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return SliderScalar(label, data_type, p_data, p_min, p_max, format, slider_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss 0x2b954(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
jne 0x1452f1
jp 0x1452f1
jmp 0x145344
movss -0x34(%rbp), %xmm0
xorl %eax, %eax
movss 0x2b93c(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jne 0x145311
jp 0x145311
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x145311
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x14531a
jmp 0x14531c
jmp 0x14533b
leaq 0x49a1b(%rip), %rdi     # 0x18ed3e
leaq 0x490b6(%rip), %rsi     # 0x18e3e0
movl $0xc29, %edx            # imm = 0xC29
leaq 0x49f66(%rip), %rcx     # 0x18f29c
callq 0xd180
movl -0x38(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl -0x38(%rbp), %eax
movl %eax, (%rsp)
callq 0x144020
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SliderScalarN(char const*, int, void*, int, void const*, void const*, char const*, float)
bool ImGui::SliderScalarN(const char* label, ImGuiDataType data_type, void* v, int components, const void* v_min, const void* v_max, const char* format, float power)
{
    ImGuiSliderFlags slider_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        slider_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return SliderScalarN(label, data_type, v, components, v_min, v_max, format, slider_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss 0x2b891(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
jne 0x1453b4
jp 0x1453b4
jmp 0x145407
movss -0x34(%rbp), %xmm0
xorl %eax, %eax
movss 0x2b879(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jne 0x1453d4
jp 0x1453d4
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x1453d4
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1453dd
jmp 0x1453df
jmp 0x1453fe
leaq 0x49958(%rip), %rdi     # 0x18ed3e
leaq 0x48ff3(%rip), %rsi     # 0x18e3e0
movl $0xc34, %edx            # imm = 0xC34
leaq 0x49f12(%rip), %rcx     # 0x18f30b
callq 0xd180
movl -0x38(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %r10
movl -0x38(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x144780
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatFindStart(char const*)
const char* ImParseFormatFindStart(const char* fmt)
{
    while (char c = fmt[0])
    {
        if (c == '%' && fmt[1] != '%')
            return fmt;
        else if (c == '%')
            fmt++;
        fmt++;
    }
    return fmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x14549c
movsbl -0x11(%rbp), %eax
cmpl $0x25, %eax
jne 0x145477
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x25, %eax
je 0x145477
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1454a4
movsbl -0x11(%rbp), %eax
cmpl $0x25, %eax
jne 0x14548c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14548e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x145448
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatFindEnd(char const*)
const char* ImParseFormatFindEnd(const char* fmt)
{
    // Printf/scanf types modifiers: I/L/h/j/l/t/w/z. Other uppercase letters qualify as types aka end of the format.
    if (fmt[0] != '%')
        return fmt;
    const unsigned int ignored_uppercase_mask = (1 << ('I'-'A')) | (1 << ('L'-'A'));
    const unsigned int ignored_lowercase_mask = (1 << ('h'-'a')) | (1 << ('j'-'a')) | (1 << ('l'-'a')) | (1 << ('t'-'a')) | (1 << ('w'-'a')) | (1 << ('z'-'a'));
    for (char c; (c = *fmt) != 0; fmt++)
    {
        if (c >= 'A' && c <= 'Z' && ((1 << (c - 'A')) & ignored_uppercase_mask) == 0)
            return fmt + 1;
        if (c >= 'a' && c <= 'z' && ((1 << (c - 'a')) & ignored_lowercase_mask) == 0)
            return fmt + 1;
    }
    return fmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x1454d1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14557f
movl $0x900, -0x14(%rbp)     # imm = 0x900
movl $0x2480a80, -0x18(%rbp) # imm = 0x2480A80
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x145577
movsbl -0x19(%rbp), %eax
cmpl $0x41, %eax
jl 0x14552c
movsbl -0x19(%rbp), %eax
cmpl $0x5a, %eax
jg 0x14552c
movsbl -0x19(%rbp), %ecx
subl $0x41, %ecx
movl $0x1, %eax
shll %cl, %eax
andl $0x900, %eax            # imm = 0x900
cmpl $0x0, %eax
jne 0x14552c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x14557f
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jl 0x145564
movsbl -0x19(%rbp), %eax
cmpl $0x7a, %eax
jg 0x145564
movsbl -0x19(%rbp), %ecx
subl $0x61, %ecx
movl $0x1, %eax
shll %cl, %eax
andl $0x2480a80, %eax        # imm = 0x2480A80
cmpl $0x0, %eax
jne 0x145564
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x14557f
jmp 0x145566
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1454df
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatTrimDecorations(char const*, char*, unsigned long)
const char* ImParseFormatTrimDecorations(const char* fmt, char* buf, size_t buf_size)
{
    const char* fmt_start = ImParseFormatFindStart(fmt);
    if (fmt_start[0] != '%')
        return fmt;
    const char* fmt_end = ImParseFormatFindEnd(fmt_start);
    if (fmt_end[0] == 0) // If we only have leading decoration, we don't need to copy the data.
        return fmt_start;
    ImStrncpy(buf, fmt_start, ImMin((size_t)(fmt_end - fmt_start) + 1, buf_size));
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x145440
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x1455c7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14562a
movq -0x28(%rbp), %rdi
callq 0x1454b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1455ea
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14562a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
subq %rax, %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
callq 0x145640
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0xc4780
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatPrecision(char const*, int)
int ImParseFormatPrecision(const char* fmt, int default_precision)
{
    fmt = ImParseFormatFindStart(fmt);
    if (fmt[0] != '%')
        return default_precision;
    fmt++;
    while (*fmt >= '0' && *fmt <= '9')
        fmt++;
    int precision = INT_MAX;
    if (*fmt == '.')
    {
        fmt = ImAtoi<int>(fmt + 1, &precision);
        if (precision < 0 || precision > 99)
            precision = default_precision;
    }
    if (*fmt == 'e' || *fmt == 'E') // Maximum precision with scientific notation
        precision = -1;
    if ((*fmt == 'g' || *fmt == 'G') && precision == INT_MAX)
        precision = -1;
    return (precision == INT_MAX) ? default_precision : precision;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x145440
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x1456a3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x145787
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
jl 0x1456d0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1456d9
jmp 0x1456e7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1456af
movl $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x145723
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x18(%rbp), %rsi
callq 0x145790
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x14571b
cmpl $0x63, -0x18(%rbp)
jle 0x145721
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x145723
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
je 0x14573b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x45, %eax
jne 0x145742
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x67, %eax
je 0x14575a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
jne 0x14576a
cmpl $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jne 0x14576a
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
cmpl $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jne 0x14577b
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x145781
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: char const* ImAtoi<int>(char const*, int*)
static const char* ImAtoi(const char* src, TYPE* output)
{
    int negative = 0;
    if (*src == '-') { negative = 1; src++; }
    if (*src == '+') { src++; }
    TYPE v = 0;
    while (*src >= '0' && *src <= '9')
        v = (v * 10) + (*src++ - '0');
    *output = negative ? -v : v;
    return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1457c2
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x1457da
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
jl 0x145802
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x14580b
jmp 0x14582b
imull $0xa, -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x1457e1
cmpl $0x0, -0x14(%rbp)
je 0x14583b
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x145841
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TempInputText(ImRect const&, unsigned int, char const*, char*, int, int)
bool ImGui::TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags)
{
    // On the first frame, g.TempInputTextId == 0, then on subsequent frames it becomes == id.
    // We clear ActiveID on the first frame to allow the InputText() taking it back.
    ImGuiContext& g = *GImGui;
    const bool init = (g.TempInputId != id);
    if (init)
        ClearActiveID();

    g.CurrentWindow->DC.CursorPos = bb.Min;
    bool value_changed = InputTextEx(label, NULL, buf, buf_size, bb.GetSize(), flags);
    if (init)
    {
        // First frame we started displaying the InputText widget, we expect it to take the active id.
        IM_ASSERT(g.ActiveId == id);
        g.TempInputId = g.ActiveId;
    }
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
leaq 0xcd6ca(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x3068(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x14589d
callq 0xca040
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq (%rcx), %rcx
movq %rcx, 0xd8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xeb560
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %ecx
movlpd %xmm0, -0x3c(%rbp)
movl -0x28(%rbp), %r9d
xorl %eax, %eax
movl %eax, %esi
leaq -0x3c(%rbp), %r8
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x145970
andb $0x1, %al
movb %al, -0x32(%rbp)
testb $0x1, -0x31(%rbp)
je 0x145956
movq -0x30(%rbp), %rax
movl 0x1b30(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x145923
jmp 0x145942
leaq 0x49a56(%rip), %rdi     # 0x18f380
leaq 0x48aaf(%rip), %rsi     # 0x18e3e0
movl $0xca9, %edx            # imm = 0xCA9
leaq 0x49a54(%rip), %rcx     # 0x18f391
callq 0xd180
movq -0x30(%rbp), %rax
movl 0x1b30(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x3068(%rax)
movb -0x32(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiInputTextCallbackData::DeleteChars(int, int)
void ImGuiInputTextCallbackData::DeleteChars(int pos, int bytes_count)
{
    IM_ASSERT(pos + bytes_count <= BufTextLen);
    char* dst = Buf + pos;
    const char* src = Buf + pos + bytes_count;
    while (char c = *src++)
        *dst++ = c;
    *dst = '\0';

    if (CursorPos >= pos + bytes_count)
        CursorPos -= bytes_count;
    else if (CursorPos >= pos)
        CursorPos = pos;
    SelectionStart = SelectionEnd = CursorPos;
    BufDirty = true;
    BufTextLen -= bytes_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl 0x20(%rcx), %eax
jg 0x14b3f7
jmp 0x14b416
leaq 0x44107(%rip), %rdi     # 0x18f505
leaq 0x42fdb(%rip), %rsi     # 0x18e3e0
movl $0xe56, %edx            # imm = 0xE56
leaq 0x44114(%rip), %rcx     # 0x18f525
callq 0xd180
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
cmpb $0x0, -0x21(%rbp)
je 0x14b46f
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x14b43f
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rcx)
movl 0x2c(%rax), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jl 0x14b498
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %edx
movl 0x2c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x14b4b0
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x14b4ae
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x2c(%rax)
jmp 0x14b4b0
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %ecx
movl %ecx, 0x34(%rax)
movl %ecx, 0x30(%rax)
movb $0x1, 0x28(%rax)
movl -0x10(%rbp), %edx
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_textedit.h
// Function: ImStb::stb_textedit_click(ImGuiInputTextState*, ImStb::STB_TexteditState*, float, float)
static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
{
   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
   if( state->single_line )
   {
      StbTexteditRow r;
      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
      y = r.ymin;
   }

   state->cursor = stb_text_locate_coord(str, x, y);
   state->select_start = state->cursor;
   state->select_end = state->cursor;
   state->has_preferred_x = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x17(%rax)
je 0x14b77d
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x159a60
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
callq 0x15a3e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x16(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_textedit.h
// Function: ImStb::stb_textedit_drag(ImGuiInputTextState*, ImStb::STB_TexteditState*, float, float)
static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
{
   int p = 0;

   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
   if( state->single_line )
   {
      StbTexteditRow r;
      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
      y = r.ymin;
   }

   if (state->select_start == state->select_end)
      state->select_start = state->cursor;

   p = stb_text_locate_coord(str, x, y);
   state->cursor = state->select_end = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x17(%rax)
je 0x14b804
movq -0x8(%rbp), %rsi
leaq -0x34(%rbp), %rdi
xorl %edx, %edx
callq 0x159a60
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x14b821
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
callq 0x15a3e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_textedit.h
// Function: ImStb::stb_textedit_cut(ImGuiInputTextState*, ImStb::STB_TexteditState*)
static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
{
   if (STB_TEXT_HAS_SELECTION(state)) {
      stb_textedit_delete_selection(str,state); // implicitly clamps
      state->has_preferred_x = 0;
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x14bb4e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1590d0
movq -0x18(%rbp), %rax
movb $0x0, 0x16(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x14bb55
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImStb::stb_textedit_replace(ImGuiInputTextState*, ImStb::STB_TexteditState*, unsigned short const*, int)
static void stb_textedit_replace(STB_TEXTEDIT_STRING* str, STB_TexteditState* state, const STB_TEXTEDIT_CHARTYPE* text, int text_len)
{
    stb_text_makeundo_replace(str, state, 0, str->CurLenW, text_len);
    ImStb::STB_TEXTEDIT_DELETECHARS(str, 0, str->CurLenW);
    if (text_len <= 0)
        return;
    if (ImStb::STB_TEXTEDIT_INSERTCHARS(str, 0, text, text_len))
    {
        state->cursor = text_len;
        state->has_preferred_x = 0;
        return;
    }
    IM_ASSERT(0); // Failed to insert character, normally shouldn't happen because of how we currently use stb_textedit_replace()
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movl -0x1c(%rbp), %r8d
xorl %edx, %edx
callq 0x158d80
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
xorl %esi, %esi
callq 0x158e00
cmpl $0x0, -0x1c(%rbp)
jg 0x14bbeb
jmp 0x14bc35
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %esi, %esi
callq 0x158ed0
testb $0x1, %al
jne 0x14bc03
jmp 0x14bc16
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x16(%rax)
jmp 0x14bc35
leaq 0x294ed(%rip), %rdi     # 0x17510a
leaq 0x427bc(%rip), %rsi     # 0x18e3e0
movl $0xe40, %edx            # imm = 0xE40
leaq 0x44b3b(%rip), %rcx     # 0x19076b
callq 0xd180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: InputTextCalcTextLenAndLineCount(char const*, char const**)
static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end)
{
    int line_count = 0;
    const char* s = text_begin;
    while (char c = *s++) // We are only matching for \n so we can ignore UTF-8 decoding
        if (c == '\n')
            line_count++;
    s--;
    if (s[0] != '\n' && s[0] != '\r')
        line_count++;
    *out_text_end = s;
    return line_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
cmpb $0x0, -0x21(%rbp)
je 0x14be29
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x14be27
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14bdfb
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x14be56
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x14be56
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ColorPicker3(char const*, float*, int)
bool ImGui::ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags)
{
    float col4[4] = { col[0], col[1], col[2], 1.0f };
    if (!ColorPicker4(label, col4, flags | ImGuiColorEditFlags_NoAlpha))
        return false;
    col[0] = col4[0]; col[1] = col4[1]; col[2] = col4[2];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x20988(%rip), %xmm0    # 0x170c3c
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
orl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x14dd20
testb $0x1, %al
jne 0x1502da
movb $0x0, -0x1(%rbp)
jmp 0x150307
movss -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeExV(char const*, int, char const*, __va_list_tag*)
bool ImGui::TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(str_id), flags, g.TempBuffer, label_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
callq 0xeb270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x150eb3
movb $0x0, -0x1(%rbp)
jmp 0x150f2b
leaq 0xc2086(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x3378, %rax           # imm = 0x3378
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq $0x3378, %rdi           # imm = 0x3378
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0xc01, %esi            # imm = 0xC01
callq 0xc4e20
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, %edi
movl -0x14(%rbp), %esi
movq -0x38(%rbp), %rdx
addq $0x3378, %rdx           # imm = 0x3378
movq -0x40(%rbp), %rcx
callq 0x151110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeExV(void const*, int, char const*, __va_list_tag*)
bool ImGui::TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(ptr_id), flags, g.TempBuffer, label_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
callq 0xeb270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x151023
movb $0x0, -0x1(%rbp)
jmp 0x151097
leaq 0xc1f16(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x3378, %rax           # imm = 0x3378
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq $0x3378, %rdi           # imm = 0x3378
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0xc01, %esi            # imm = 0xC01
callq 0xc4e20
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc9ae0
movl %eax, %edi
movl -0x14(%rbp), %esi
movq -0x38(%rbp), %rdx
addq $0x3378, %rdx           # imm = 0x3378
movq -0x40(%rbp), %rcx
callq 0x151110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNode(char const*)
bool ImGui::TreeNode(const char* label)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
    return TreeNodeBehavior(window->GetID(label), 0, label, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0xeb270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x1510d8
movb $0x0, -0x1(%rbp)
jmp 0x1510ff
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, %edi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x151110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeEx(char const*, int)
bool ImGui::TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    return TreeNodeBehavior(window->GetID(label), flags, label, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0xeb270
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x151fab
movb $0x0, -0x1(%rbp)
jmp 0x151fd3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, %edi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x151110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePushOverrideID(unsigned int)
void ImGui::TreePushOverrideID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Indent();
    window->DC.TreeDepth++;
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xc0c7e(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x18(%rbp), %rax
movl 0x18c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18c(%rax)
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x4(%rbp), %rsi
callq 0xe8e70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePush(char const*)
void ImGui::TreePush(const char* str_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(str_id ? str_id : "#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xeb270
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x10(%rbp), %rax
movl 0x18c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18c(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x152351
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x15235e
leaq 0x3da5b(%rip), %rax     # 0x18fdb3
movq %rax, -0x18(%rbp)
jmp 0x15235e
movq -0x18(%rbp), %rdi
callq 0xdb440
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePush(void const*)
void ImGui::TreePush(const void* ptr_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xeb270
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x10(%rbp), %rax
movl 0x18c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18c(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x1523b1
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1523be
leaq 0x3d9fb(%rip), %rax     # 0x18fdb3
movq %rax, -0x18(%rbp)
jmp 0x1523be
movq -0x18(%rbp), %rdi
callq 0xdb500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePop()
void ImGui::TreePop()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Unindent();

    window->DC.TreeDepth--;
    ImU32 tree_depth_mask = (1 << window->DC.TreeDepth);

    // Handle Left arrow to move to parent tree node (when ImGuiTreeNodeFlags_NavLeftJumpsBackHere is enabled)
    if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window && NavMoveRequestButNoResultYet())
        if (g.NavIdIsAlive && (window->DC.TreeJumpToParentOnPopMask & tree_depth_mask))
        {
            SetNavID(window->IDStack.back(), g.NavLayer, 0);
            NavMoveRequestCancel();
        }
    window->DC.TreeJumpToParentOnPopMask &= tree_depth_mask - 1;

    IM_ASSERT(window->IDStack.Size > 1); // There should always be 1 element in the IDStack (pushed during window creation). If this triggers you called TreePop/PopID too much.
    PopID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xc0b61(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
callq 0xdca70
movq -0x10(%rbp), %rax
movl 0x18c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18c(%rax)
movq -0x10(%rbp), %rax
movl 0x18c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1d10(%rax)
jne 0x152496
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x152496
callq 0xdf630
testb $0x1, %al
jne 0x15244d
jmp 0x152496
movq -0x8(%rbp), %rax
testb $0x1, 0x1ce4(%rax)
je 0x152494
movq -0x10(%rbp), %rax
movl 0x190(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x152494
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9130
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x1cdc(%rax), %esi
xorl %edx, %edx
callq 0xdf300
callq 0xdf680
jmp 0x152496
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
andl 0x190(%rax), %ecx
movl %ecx, 0x190(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc8(%rax)
jle 0x1524bb
jmp 0x1524da
leaq 0x221a5(%rip), %rdi     # 0x174667
leaq 0x3bf17(%rip), %rsi     # 0x18e3e0
movl $0x16f8, %edx           # imm = 0x16F8
leaq 0x3d8e8(%rip), %rcx     # 0x18fdbd
callq 0xd180
callq 0xdb640
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SetNextItemOpen(bool, int)
void ImGui::SetNextItemOpen(bool is_open, ImGuiCond cond)
{
    ImGuiContext& g = *GImGui;
    if (g.CurrentWindow->SkipItems)
        return;
    g.NextItemData.Flags |= ImGuiNextItemDataFlags_HasOpen;
    g.NextItemData.OpenVal = is_open;
    g.NextItemData.OpenCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xc09fa(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
testb $0x1, 0x93(%rax)
je 0x152563
jmp 0x1525ab
movq -0x10(%rbp), %rax
movl 0x1bf8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1bf8(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1c08(%rax)
cmpl $0x0, -0x8(%rbp)
je 0x152594
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x15259e
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15259e
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c04(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::CollapsingHeader(char const*, int)
bool ImGui::CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    return TreeNodeBehavior(window->GetID(label), flags | ImGuiTreeNodeFlags_CollapsingHeader, label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0xeb270
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x1525db
movb $0x0, -0x1(%rbp)
jmp 0x152606
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, %edi
movl -0x14(%rbp), %esi
orl $0x1a, %esi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x151110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Selectable(char const*, bool*, int, ImVec2 const&)
bool ImGui::Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)
{
    if (Selectable(label, *p_selected, flags, size_arg))
    {
        *p_selected = !*p_selected;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
andb $0x1, %al
movzbl %al, %esi
callq 0x13f2b0
testb $0x1, %al
jne 0x1527e8
jmp 0x152800
movq -0x18(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x152804
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ListBoxHeader(char const*, int, int)
bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items)
{
    // Size default to hold ~7.25 items.
    // We add +25% worth of item height to allow the user to see at a glance if there are more items up/down, without looking at the scrollbar.
    // We don't add this extra bit if items_count <= height_in_items. It is slightly dodgy, because it means a dynamic list of items will make the widget resize occasionally when it crosses that size.
    // I am expecting that someone will come and complain about this behavior in a remote future, then we can advise on a better solution.
    if (height_in_items < 0)
        height_in_items = ImMin(items_count, 7);
    const ImGuiStyle& style = GetStyle();
    float height_in_items_f = (height_in_items < items_count) ? (height_in_items + 0.25f) : (height_in_items + 0.00f);

    // We include ItemSpacing.y so that a list sized for the exact number of items doesn't make a scrollbar appears. We could also enforce that by passing a flag to BeginChild().
    ImVec2 size;
    size.x = 0.0f;
    size.y = ImFloor(GetTextLineHeightWithSpacing() * height_in_items_f + style.FramePadding.y * 2.0f);
    return ListBoxHeader(label, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x152b28
movl -0xc(%rbp), %edi
movl $0x7, %esi
callq 0x143780
movl %eax, -0x10(%rbp)
callq 0xc7680
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x152b51
cvtsi2ssl -0x10(%rbp), %xmm0
movss 0x1f472(%rip), %xmm1    # 0x171fb8
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x152b62
cvtsi2ssl -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
leaq -0x24(%rbp), %rdi
callq 0xe7de0
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0xdd020
movss -0x1c(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x1f439(%rip), %xmm1    # 0x171fcc
mulss 0x3c(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x13e6a0
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x152810
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ListBoxFooter()
void ImGui::ListBoxFooter()
{
    ImGuiWindow * window = GetCurrentWindow();
    IM_ASSERT((window->Flags & ImGuiWindowFlags_ChildWindow) && "Mismatched ListBoxHeader/ListBoxFooter calls. Did you test the return value of ListBoxHeader()?");
    ImGuiWindow* parent_window = window->ParentWindow;
    const ImRect bb = parent_window->DC.LastItemRect;
    const ImGuiStyle& style = GetStyle();

    EndChildFrame();

    // Redeclare item size so that it includes the label (we have stored the full size in LastItemRect)
    // We call SameLine() to restore DC.CurrentLine* data
    SameLine();
    parent_window->DC.CursorPos = bb.Min;
    ItemSize(bb, style.FramePadding.y);
    EndGroup();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xeb270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x152bef
movb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x152bef
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x152bf8
jmp 0x152bfa
jmp 0x152c19
leaq 0x3d232(%rip), %rdi     # 0x18fe33
leaq 0x3b7d8(%rip), %rsi     # 0x18e3e0
movl $0x1829, %edx           # imm = 0x1829
leaq 0x3d2b3(%rip), %rcx     # 0x18fec7
callq 0xd180
movq -0x8(%rbp), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x12c(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x134(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0xc7680
movq %rax, -0x28(%rbp)
callq 0xd64c0
xorps %xmm0, %xmm0
movss 0x1f325(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0xd8(%rax)
movq -0x28(%rbp), %rax
movss 0x3c(%rax), %xmm0
leaq -0x20(%rbp), %rdi
callq 0xdc300
callq 0xdbe80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Value(char const*, float, char const*)
void ImGui::Value(const char* prefix, float v, const char* float_format)
{
    if (float_format)
    {
        char fmt[64];
        ImFormatString(fmt, IM_ARRAYSIZE(fmt), "%%s: %s", float_format);
        Text(fmt, prefix, v);
    }
    else
    {
        Text("%s: %.3f", prefix, v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x153e71
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x40, %esi
leaq 0x3c173(%rip), %rdx     # 0x18ffc3
movb $0x0, %al
callq 0xc4d30
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movb $0x1, %al
callq 0x139160
jmp 0x153e8c
movq -0x8(%rbp), %rsi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3c146(%rip), %rdi     # 0x18ffcb
movb $0x1, %al
callq 0x139160
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiMenuColumns::Update(int, float, bool)
void ImGuiMenuColumns::Update(int count, float spacing, bool clear)
{
    IM_ASSERT(count == IM_ARRAYSIZE(Pos));
    IM_UNUSED(count);
    Width = NextWidth = 0.0f;
    Spacing = spacing;
    if (clear)
        memset(NextWidths, 0, sizeof(NextWidths));
    for (int i = 0; i < IM_ARRAYSIZE(Pos); i++)
    {
        if (i > 0 && NextWidths[i] > 0.0f)
            Width += Spacing;
        Pos[i] = IM_FLOOR(Width);
        Width += NextWidths[i];
        NextWidths[i] = 0.0f;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x153ecb
jmp 0x153eea
leaq 0x3c102(%rip), %rdi     # 0x18ffd4
leaq 0x3a507(%rip), %rsi     # 0x18e3e0
movl $0x193d, %edx           # imm = 0x193D
leaq 0x3c11e(%rip), %rcx     # 0x190003
callq 0xd180
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, (%rax)
testb $0x1, -0x11(%rbp)
je 0x153f21
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0xd2f0
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x153f9f
cmpl $0x0, -0x18(%rbp)
jle 0x153f5c
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x18(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x153f5c
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
cvttss2si 0x4(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movslq -0x18(%rbp), %rcx
movss %xmm0, 0xc(%rax,%rcx,4)
movslq -0x18(%rbp), %rcx
movss 0x18(%rax,%rcx,4), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movslq -0x18(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x153f28
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiMenuColumns::DeclColumns(float, float, float)
float ImGuiMenuColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
    NextWidth = 0.0f;
    NextWidths[0] = ImMax(NextWidths[0], w0);
    NextWidths[1] = ImMax(NextWidths[1], w1);
    NextWidths[2] = ImMax(NextWidths[2], w2);
    for (int i = 0; i < IM_ARRAYSIZE(Pos); i++)
        NextWidth += NextWidths[i] + ((i > 0 && NextWidths[i] > 0.0f) ? Spacing : 0.0f);
    return ImMax(Width, NextWidth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movss 0x18(%rax), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x139050
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movss 0x1c(%rax), %xmm0
movss -0x10(%rbp), %xmm1
callq 0x139050
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movss 0x20(%rax), %xmm0
movss -0x14(%rbp), %xmm1
callq 0x139050
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x15409f
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x18(%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x15406e
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x18(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x15406e
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x154078
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x154078
movq -0x20(%rbp), %rax
movss -0x24(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
addss %xmm1, %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15402a
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss 0x8(%rax), %xmm1
callq 0x139050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)