LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::SetInt(unsigned int, int)
void ImGuiStorage::SetInt(ImU32 key, int val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, Pair(key, val));
        return;
    }
    it->val_i = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xabce
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xabf8
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x2d500
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d390
jmp 0xac02
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::SetFloat(unsigned int, float)
void ImGuiStorage::SetFloat(ImU32 key, float val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, Pair(key, val));
        return;
    }
    it->val_f = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xac60
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xac8c
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x2d520
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d390
jmp 0xac9a
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::SetVoidPtr(unsigned int, void*)
void ImGuiStorage::SetVoidPtr(ImU32 key, void* val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, Pair(key, val));
        return;
    }
    it->val_p = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xacef
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xad1a
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2d550
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2d390
jmp 0xad26
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::ImGuiTextFilter(char const*)
ImGuiTextFilter::ImGuiTextFilter(const char* default_filter)
{
    if (default_filter)
    {
        ImFormatString(InputBuf, IM_ARRAYSIZE(InputBuf), "%s", default_filter);
        Build();
    }
    else
    {
        InputBuf[0] = 0;
        CountGrep = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq %rdi, -0x28(%rbp)
callq 0x2d5e0
cmpq $0x0, -0x10(%rbp)
je 0xadfe
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x55477(%rip), %rdx     # 0x60245
xorl %eax, %eax
movl $0x100, %esi            # imm = 0x100
callq 0x95a0
movq -0x30(%rbp), %rdi
callq 0xae20
jmp 0xade5
jmp 0xae0f
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2d610
jmp 0xae15
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, 0x110(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x74f0
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::Build()
void ImGuiTextFilter::Build()
{
    Filters.resize(0);
    TextRange input_range(InputBuf, InputBuf+strlen(InputBuf));
    input_range.split(',', Filters);

    CountGrep = 0;
    for (int i = 0; i != Filters.Size; i++)
    {
        Filters[i].trim_blanks();
        if (Filters[i].empty())
            continue;
        if (Filters[i].front() != '-')
            CountGrep += 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x100, %rdi            # imm = 0x100
xorl %esi, %esi
callq 0x2d650
movq -0x28(%rbp), %rdi
callq 0x7330
movq -0x28(%rbp), %rsi
movq %rsi, %rdx
addq %rax, %rdx
leaq -0x18(%rbp), %rdi
callq 0x2d710
movq -0x28(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0xb180
movq -0x28(%rbp), %rax
movl $0x0, 0x110(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x100(%rcx), %eax
je 0xaf23
movq -0x28(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x1c(%rbp), %esi
callq 0x2d740
movq %rax, %rdi
callq 0x2d7a0
movq -0x28(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x1c(%rbp), %esi
callq 0x2d740
movq %rax, %rdi
callq 0x2d840
testb $0x1, %al
jne 0xaedb
jmp 0xaedd
jmp 0xaf15
movq -0x28(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x1c(%rbp), %esi
callq 0x2d740
movq %rax, %rdi
callq 0x2d860
movsbl %al, %eax
cmpl $0x2d, %eax
je 0xaf13
movq -0x28(%rbp), %rax
movl 0x110(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x110(%rax)
jmp 0xaf15
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xae8c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::Draw(char const*, float)
bool ImGuiTextFilter::Draw(const char* label, float width)
{
    if (width != 0.0f)
        ImGui::PushItemWidth(width);
    bool value_changed = ImGui::InputText(label, InputBuf, IM_ARRAYSIZE(InputBuf));
    if (width != 0.0f)
        ImGui::PopItemWidth();
    if (value_changed)
        Build();
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xaf5e
jp 0xaf5e
jmp 0xaf68
movss -0x14(%rbp), %xmm0
callq 0xafc0
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0xb040
andb $0x1, %al
movb %al, -0x15(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xaf9a
jp 0xaf9a
jmp 0xaf9f
callq 0xb0f0
testb $0x1, -0x15(%rbp)
je 0xafae
movq -0x20(%rbp), %rdi
callq 0xae20
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::TextRange::split(char, ImVector<ImGuiTextFilter::TextRange>&)
void ImGuiTextFilter::TextRange::split(char separator, ImVector<TextRange>& out)
{
    out.resize(0);
    const char* wb = b;
    const char* we = wb;
    while (we < e)
    {
        if (*we == separator)
        {
            out.push_back(TextRange(wb, we));
            wb = we + 1;
        }
        we++;
    }
    if (wb != we)
        out.push_back(TextRange(wb, we));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2d650
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xb219
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb20b
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2d710
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2d6a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb1bc
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xb249
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2d710
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2d6a0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::PassFilter(char const*, char const*) const
bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
    if (Filters.empty())
        return true;

    if (text == NULL)
        text = "";

    for (int i = 0; i != Filters.Size; i++)
    {
        const TextRange& f = Filters[i];
        if (f.empty())
            continue;
        if (f.front() == '-')
        {
            // Subtract
            if (ImStristr(text, text_end, f.begin()+1, f.end()) != NULL)
                return false;
        }
        else
        {
            // Grep
            if (ImStristr(text, text_end, f.begin(), f.end()) != NULL)
                return true;
        }
    }

    // Implicit * grep
    if (CountGrep == 0)
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x2d880
testb $0x1, %al
jne 0xb27e
jmp 0xb287
movb $0x1, -0x1(%rbp)
jmp 0xb3aa
cmpq $0x0, -0x18(%rbp)
jne 0xb299
leaq 0x53fb9(%rip), %rax     # 0x5f24e
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x100(%rcx), %eax
je 0xb393
movq -0x38(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x24(%rbp), %esi
callq 0x2d8a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d840
testb $0x1, %al
jne 0xb2d9
jmp 0xb2de
jmp 0xb385
movq -0x30(%rbp), %rdi
callq 0x2d860
movsbl %al, %eax
cmpl $0x2d, %eax
jne 0xb33b
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d900
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d920
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
callq 0x9460
cmpq $0x0, %rax
je 0xb339
movb $0x0, -0x1(%rbp)
jmp 0xb3aa
jmp 0xb383
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d900
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d920
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
callq 0x9460
cmpq $0x0, %rax
je 0xb381
movb $0x1, -0x1(%rbp)
jmp 0xb3aa
jmp 0xb383
jmp 0xb385
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb2a0
movq -0x38(%rbp), %rax
cmpl $0x0, 0x110(%rax)
jne 0xb3a6
movb $0x1, -0x1(%rbp)
jmp 0xb3aa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextBuffer::appendv(char const*, __va_list_tag*)
void ImGuiTextBuffer::appendv(const char* fmt, va_list args)
{
    va_list args_copy;
    va_copy(args_copy, args);

    int len = vsnprintf(NULL, 0, fmt, args);         // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
    if (len <= 0)
        return;

    const int write_off = Buf.Size;
    const int needed_sz = write_off + len;
    if (write_off + len >= Buf.Capacity)
    {
        int double_capacity = Buf.Capacity * 2;
        Buf.reserve(needed_sz > double_capacity ? needed_sz : double_capacity);
    }

    Buf.resize(needed_sz);
    ImFormatStringV(&Buf[write_off] - 1, len+1, fmt, args_copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x7500
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jg 0xb411
jmp 0xb48e
movq -0x48(%rbp), %rcx
movl (%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0xb45c
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jle 0xb44a
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0xb450
movl -0x40(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2d940
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x2d9c0
movq -0x48(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x2da10
movq %rax, %rdi
addq $-0x1, %rdi
movl -0x34(%rbp), %esi
addl $0x1, %esi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x9680
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiSimpleColumns::ImGuiSimpleColumns()
ImGuiSimpleColumns::ImGuiSimpleColumns()
{
    Count = 0;
    Spacing = Width = NextWidth = 0.0f;
    memset(Pos, 0, sizeof(Pos));
    memset(NextWidths, 0, sizeof(NextWidths));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rdi)
addq $0x10, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7240
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiSimpleColumns::Update(int, float, bool)
void ImGuiSimpleColumns::Update(int count, float spacing, bool clear)
{
    IM_ASSERT(Count <= IM_ARRAYSIZE(Pos));
    Count = count;
    Width = NextWidth = 0.0f;
    Spacing = spacing;
    if (clear) memset(NextWidths, 0, sizeof(NextWidths));
    for (int i = 0; i < Count; i++)
    {
        if (i > 0 && NextWidths[i] > 0.0f)
            Width += Spacing;
        Pos[i] = (float)(int)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 $0x8, (%rax)
jg 0xb5ca
jmp 0xb5e9
leaq 0x4fd7f(%rip), %rdi     # 0x5b350
leaq 0x4fced(%rip), %rsi     # 0x5b2c5
movl $0x5a2, %edx            # imm = 0x5A2
leaq 0x4fd97(%rip), %rcx     # 0x5b37b
callq 0x7160
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
testb $0x1, -0x11(%rbp)
je 0xb626
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7240
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb6aa
cmpl $0x0, -0x18(%rbp)
jle 0xb667
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x30(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xb667
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
cvttss2si 0x8(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movslq -0x18(%rbp), %rcx
movss %xmm0, 0x10(%rax,%rcx,4)
movslq -0x18(%rbp), %rcx
movss 0x30(%rax,%rcx,4), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movslq -0x18(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb62d
addq $0x20, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiSimpleColumns::DeclColumns(float, float, float)
float ImGuiSimpleColumns::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 < 3; 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, 0xc(%rax)
movss 0x30(%rax), %xmm0
movss -0xc(%rbp), %xmm1
callq 0xb7c0
movq -0x20(%rbp), %rax
movss %xmm0, 0x30(%rax)
movss 0x34(%rax), %xmm0
movss -0x10(%rbp), %xmm1
callq 0xb7c0
movq -0x20(%rbp), %rax
movss %xmm0, 0x34(%rax)
movss 0x38(%rax), %xmm0
movss -0x14(%rbp), %xmm1
callq 0xb7c0
movq -0x20(%rbp), %rax
movss %xmm0, 0x38(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0xb7a0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x30(%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0xb76f
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0x30(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xb76f
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0xb779
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0xb779
movq -0x20(%rbp), %rax
movss -0x24(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
addss %xmm1, %xmm0
addss 0xc(%rax), %xmm0
movss %xmm0, 0xc(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb72a
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0xc(%rax), %xmm1
callq 0xb7c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::GetID(char const*, char const*)
ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHash(str, str_end ? (int)(str_end - str) : 0, seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x2e160
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbca8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0xbcaf
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbcaf
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x96e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0xbd70
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::~ImGuiWindow()
ImGuiWindow::~ImGuiWindow()
{
    DrawList->~ImDrawList();
    ImGui::MemFree(DrawList);
    DrawList = NULL;
    ImGui::MemFree(Name);
    Name = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x270(%rax), %rdi
callq 0x2e0c0
movq -0x10(%rbp), %rax
movq 0x270(%rax), %rdi
callq 0xa760
jmp 0xbd12
movq -0x10(%rbp), %rax
movq $0x0, 0x270(%rax)
movq (%rax), %rdi
callq 0xa760
jmp 0xbd2b
movq -0x10(%rbp), %rdi
movq $0x0, (%rdi)
addq $0x258, %rdi            # imm = 0x258
callq 0x2dfd0
movq -0x10(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x2dff0
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2e030
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2e150
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::GetID(void const*)
ImGuiID ImGuiWindow::GetID(const void* ptr)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHash(&ptr, sizeof(void*), seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x2e160
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x96e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0xbd70
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetActiveID(unsigned int, ImGuiWindow*)
void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window = NULL)
{
    ImGuiState& g = *GImGui;
    g.ActiveId = id;
    g.ActiveIdIsFocusedOnly = false;
    g.ActiveIdIsJustActivated = true;
    g.ActiveIdWindow = window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x6d64e(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1790(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x179a(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x1799(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x17a0(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ItemSize(ImVec2 const&, float)
void ImGui::ItemSize(const ImVec2& size, float text_offset_y)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    // Always align ourselves on pixel boundaries
    ImGuiState& g = *GImGui;
    const float line_height = ImMax(window->DC.CurrentLineHeight, size.y);
    const float text_base_offset = ImMax(window->DC.CurrentLineTextBaseOffset, text_offset_y);
    window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y);
    window->DC.CursorPos = ImVec2((float)(int)(window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX), (float)(int)(window->DC.CursorPos.y + line_height + g.Style.ItemSpacing.y));
    window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPosPrevLine.x);
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y);

    //window->DrawList->AddCircle(window->DC.CursorMaxPos, 3.0f, 0xFF0000FF, 4); // Debug

    window->DC.PrevLineHeight = line_height;
    window->DC.PrevLineTextBaseOffset = text_base_offset;
    window->DC.CurrentLineHeight = window->DC.CurrentLineTextBaseOffset = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
callq 0x2e220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0xbed9
jmp 0xc04e
movq 0x6d5e0(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0xc8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm1
callq 0xb7c0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss 0xcc(%rax), %xmm0
movss -0xc(%rbp), %xmm1
callq 0xb7c0
movss %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movss 0xa8(%rax), %xmm0
movq -0x8(%rbp), %rax
addss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xac(%rax), %xmm1
leaq -0x30(%rbp), %rdi
callq 0x2d280
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x194(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x198(%rax), %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movq -0x18(%rbp), %rax
movss 0xac(%rax), %xmm1
addss -0x24(%rbp), %xmm1
movq -0x20(%rbp), %rax
addss 0x1418(%rax), %xmm1
cvttss2si %xmm1, %eax
cvtsi2ss %eax, %xmm1
leaq -0x38(%rbp), %rdi
callq 0x2d280
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x18(%rbp), %rax
movss 0xc0(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xb0(%rax), %xmm1
callq 0xb7c0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movss 0xc4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xac(%rax), %xmm1
callq 0xb7c0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc4(%rax)
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xd0(%rax)
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xd4(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xcc(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsClippedEx(ImRect const&, unsigned int const*, bool)
bool ImGui::IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();

    if (!bb.Overlaps(window->ClipRect))
    {
        if (!id || *id != GImGui->ActiveId)
            if (clip_even_when_logged || !g.LogEnabled)
                return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq 0x6d282(%rip), %rax     # 0x794c0
movq %rax, -0x28(%rbp)
callq 0x2e290
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
callq 0x2e2b0
testb $0x1, %al
jne 0xc29c
cmpq $0x0, -0x18(%rbp)
je 0xc27f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq 0x6d249(%rip), %rcx     # 0x794c0
cmpl 0x1790(%rcx), %eax
je 0xc29a
testb $0x1, -0x19(%rbp)
jne 0xc292
movq -0x28(%rbp), %rax
testb $0x1, 0x2be8(%rax)
jne 0xc298
movb $0x1, -0x1(%rbp)
jmp 0xc2a0
jmp 0xc29a
jmp 0xc29c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseHoveringRect(ImVec2 const&, ImVec2 const&, bool)
bool ImGui::IsMouseHoveringRect(const ImVec2& pos_min, const ImVec2& pos_max, bool clip)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();

    // Clip
    ImRect rect_clipped(pos_min, pos_max);
    if (clip)
        rect_clipped.Clip(window->ClipRect);

    // Expand for touch input
    const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
    return rect_for_touch.Contains(g.IO.MousePos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x6d1f2(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
callq 0x2e290
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2eb40
testb $0x1, -0x11(%rbp)
je 0xc306
movq -0x28(%rbp), %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x38(%rbp), %rdi
callq 0x2eb70
movq -0x20(%rbp), %rsi
addq $0x1424, %rsi           # imm = 0x1424
leaq -0x38(%rbp), %rdi
callq 0xdf20
movlpd %xmm0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1424, %rsi           # imm = 0x1424
callq 0xc7e0
movlpd %xmm0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x2eb40
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0xe8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2ec20
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: IsWindowContentHoverable(ImGuiWindow*)
static inline bool IsWindowContentHoverable(ImGuiWindow* window)
{
    // An active popup disable hovering on other windows (apart from its own children)
    ImGuiState& g = *GImGui;
    if (ImGuiWindow* focused_window = g.FocusedWindow)
        if (ImGuiWindow* focused_root_window = focused_window->RootWindow)
            if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) != 0 && focused_root_window->WasActive && focused_root_window != window->RootWindow)
                return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x6d141(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1770(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc3e5
movq -0x20(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc3e3
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0xc3e1
movq -0x28(%rbp), %rax
testb $0x1, 0x71(%rax)
je 0xc3e1
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x278(%rcx), %rax
je 0xc3e1
movb $0x0, -0x1(%rbp)
jmp 0xc3e9
jmp 0xc3e3
jmp 0xc3e5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsHovered(ImRect const&, unsigned int, bool)
bool ImGui::IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs)
{
    ImGuiState& g = *GImGui;
    if (g.HoveredId == 0 || g.HoveredId == id)
    {
        ImGuiWindow* window = GetCurrentWindowRead();
        if (g.HoveredWindow == window || (flatten_childs && g.HoveredRootWindow == window->RootWindow))
            if ((g.ActiveId == 0 || g.ActiveId == id || g.ActiveIdIsFocusedOnly) && ImGui::IsMouseHoveringRect(bb.Min, bb.Max))
                if (IsWindowContentHoverable(g.HoveredRootWindow))
                    return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq 0x6d0b3(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1788(%rax)
je 0xc431
movq -0x20(%rbp), %rax
movl 0x1788(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xc4d0
callq 0x2e290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x1778(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0xc469
testb $0x1, -0x15(%rbp)
je 0xc4ce
movq -0x20(%rbp), %rax
movq 0x1780(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x278(%rcx), %rax
jne 0xc4ce
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1790(%rax)
je 0xc492
movq -0x20(%rbp), %rax
movl 0x1790(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xc492
movq -0x20(%rbp), %rax
testb $0x1, 0x179a(%rax)
je 0xc4cc
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0xc2b0
testb $0x1, %al
jne 0xc4ae
jmp 0xc4cc
movq -0x20(%rbp), %rax
movq 0x1780(%rax), %rdi
callq 0xc370
testb $0x1, %al
jne 0xc4c4
jmp 0xc4ca
movb $0x1, -0x1(%rbp)
jmp 0xc4d4
jmp 0xc4cc
jmp 0xc4ce
jmp 0xc4d0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::FocusableItemRegister(ImGuiWindow*, bool, bool)
bool ImGui::FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop)
{
    ImGuiState& g = *GImGui;

    const bool allow_keyboard_focus = window->DC.AllowKeyboardFocus;
    window->FocusIdxAllCounter++;
    if (allow_keyboard_focus)
        window->FocusIdxTabCounter++;

    // Process keyboard input at this point: TAB, Shift-TAB switch focus
    // We can always TAB out of a widget that doesn't allow tabbing in.
    if (tab_stop && window->FocusIdxAllRequestNext == IM_INT_MAX && window->FocusIdxTabRequestNext == IM_INT_MAX && is_active && IsKeyPressedMap(ImGuiKey_Tab))
    {
        // Modulo on index will be applied at the end of frame once we've got the total counter of items.
        window->FocusIdxTabRequestNext = window->FocusIdxTabCounter + (g.IO.KeyShift ? (allow_keyboard_focus ? -1 : 0) : +1);
    }

    if (window->FocusIdxAllCounter == window->FocusIdxAllRequestCurrent)
        return true;

    if (allow_keyboard_focus)
        if (window->FocusIdxTabCounter == window->FocusIdxTabRequestCurrent)
            return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq 0x6cfbd(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x124(%rax), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movl 0x288(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x288(%rax)
testb $0x1, -0x21(%rbp)
je 0xc542
movq -0x10(%rbp), %rax
movl 0x28c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28c(%rax)
testb $0x1, -0x12(%rbp)
je 0xc5cf
movq -0x10(%rbp), %rax
cmpl $0x7fffffff, 0x298(%rax) # imm = 0x7FFFFFFF
jne 0xc5cf
movq -0x10(%rbp), %rax
cmpl $0x7fffffff, 0x29c(%rax) # imm = 0x7FFFFFFF
jne 0xc5cf
testb $0x1, -0x11(%rbp)
je 0xc5cf
xorl %edi, %edi
movl $0x1, %esi
callq 0xc620
testb $0x1, %al
jne 0xc584
jmp 0xc5cf
movq -0x10(%rbp), %rax
movl 0x28c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x106(%rax)
je 0xc5b3
movb -0x21(%rbp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc5bd
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc5bd
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x29c(%rax)
movq -0x10(%rbp), %rax
movl 0x288(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x290(%rcx), %eax
jne 0xc5eb
movb $0x1, -0x1(%rbp)
jmp 0xc613
testb $0x1, -0x21(%rbp)
je 0xc60f
movq -0x10(%rbp), %rax
movl 0x28c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x294(%rcx), %eax
jne 0xc60d
movb $0x1, -0x1(%rbp)
jmp 0xc613
jmp 0xc60f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemSize(ImVec2, float, float)
ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_x, float default_y)
{
    ImGuiState& g = *GImGui;
    ImVec2 content_max;
    if (size.x < 0.0f || size.y < 0.0f)
        content_max = g.CurrentWindow->Pos + ImGui::GetContentRegionMax();
    if (size.x <= 0.0f)
        size.x = (size.x == 0.0f) ? default_x : ImMax(content_max.x - g.CurrentWindow->DC.CursorPos.x, 4.0f) + size.x;
    if (size.y <= 0.0f)
        size.y = (size.y == 0.0f) ? default_y : ImMax(content_max.y - g.CurrentWindow->DC.CursorPos.y, 4.0f) + size.y;
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movq 0x6ce12(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d230
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
ja 0xc6cd
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0xc704
movq -0x20(%rbp), %rax
movq 0x1758(%rax), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
callq 0xc830
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xc7e0
movlpd %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jb 0xc761
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc728
jp 0xc728
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
jmp 0xc757
movss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x1758(%rax), %rax
subss 0xa8(%rax), %xmm0
movss 0x4e910(%rip), %xmm1    # 0x5b058
callq 0xb7c0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jb 0xc7be
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc785
jp 0xc785
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
jmp 0xc7b4
movss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq 0x1758(%rax), %rax
subss 0xac(%rax), %xmm0
movss 0x4e8b3(%rip), %xmm1    # 0x5b058
callq 0xb7c0
addss -0xc(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetContentRegionMax()
ImVec2 ImGui::GetContentRegionMax()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImVec2 content_region_size = ImVec2(window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x - window->ScrollbarSizes.x, window->SizeContentsExplicit.y ? window->SizeContentsExplicit.y : window->Size.y - window->ScrollbarSizes.y);
    ImVec2 mx = content_region_size - window->Scroll - window->WindowPadding;
    if (window->DC.ColumnsCount != 1)
        mx.x = ImGui::GetColumnOffset(window->DC.ColumnsCurrent + 1) - window->WindowPadding.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x2e290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc856
jp 0xc856
jmp 0xc866
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0xc87d
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x68(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc89c
jp 0xc89c
jmp 0xc8ac
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xc8c3
movq -0x10(%rbp), %rax
movss 0x24(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x6c(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2d280
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
callq 0xdf20
movlpd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
leaq -0x20(%rbp), %rdi
callq 0xdf20
movlpd %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x1a0(%rax)
je 0xc933
movq -0x10(%rbp), %rax
movl 0x19c(%rax), %edi
addl $0x1, %edi
callq 0x19660
movq -0x10(%rbp), %rax
subss 0x40(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcWrapWidthForPos(ImVec2 const&, float)
float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
    if (wrap_pos_x < 0.0f)
        return 0.0f;

    ImGuiWindow* window = GetCurrentWindowRead();
    if (wrap_pos_x == 0.0f)
        wrap_pos_x = ImGui::GetContentRegionMax().x + window->Pos.x;
    else if (wrap_pos_x > 0.0f)
        wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space

    const float wrap_width = wrap_pos_x > 0.0f ? ImMax(wrap_pos_x - pos.x, 0.00001f) : 0.0f;
    return wrap_width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0xc967
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xca15
callq 0x2e290
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc99e
jp 0xc99e
callq 0xc830
movlpd %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
addss 0x18(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0xc9c9
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc9c7
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
subss 0x4c(%rax), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0xc9c9
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc9f7
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss (%rax), %xmm0
movss 0x4e6b9(%rip), %xmm1    # 0x5b0a4
callq 0xb7c0
movss %xmm0, -0x30(%rbp)
jmp 0xca01
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
jmp 0xca01
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetCurrentFont(ImFont*)
static void SetCurrentFont(ImFont* font)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(font && font->IsLoaded());
    IM_ASSERT(font->Scale > 0.0f);
    g.Font = font;
    g.FontBaseSize = g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale;
    g.FontSize = g.CurrentWindow ? g.CurrentWindow->CalcFontSize() : 0.0f;
    g.FontTexUvWhitePixel = g.Font->ContainerAtlas->TexUvWhitePixel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6b6cd(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0xde0f
movq -0x8(%rbp), %rdi
callq 0x2e390
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xde18
jmp 0xde1a
jmp 0xde39
leaq 0x4ec29(%rip), %rdi     # 0x5ca4a
leaq 0x4d49d(%rip), %rsi     # 0x5b2c5
movl $0x1067, %edx           # imm = 0x1067
leaq 0x4ec2f(%rip), %rcx     # 0x5ca63
callq 0x7160
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xde4c
jmp 0xde6b
leaq 0x4ec2e(%rip), %rdi     # 0x5ca81
leaq 0x4d46b(%rip), %rsi     # 0x5b2c5
movl $0x1068, %edx           # imm = 0x1068
leaq 0x4ebfd(%rip), %rcx     # 0x5ca63
callq 0x7160
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1710(%rax)
movq -0x10(%rbp), %rax
movss 0x98(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x1710(%rax), %rax
mulss (%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x1710(%rax), %rax
mulss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x171c(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1758(%rax)
je 0xded6
movq -0x10(%rbp), %rax
movq 0x1758(%rax), %rdi
callq 0x2e440
movss %xmm0, -0x18(%rbp)
jmp 0xdee0
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
jmp 0xdee0
movss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1718(%rax)
movq -0x10(%rbp), %rax
movq 0x1710(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x24(%rcx), %rcx
movq %rcx, 0x1720(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindHoveredWindow(ImVec2, bool)
static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs)
{
    ImGuiState& g = *GImGui;
    for (int i = g.Windows.Size-1; i >= 0; i--)
    {
        ImGuiWindow* window = g.Windows[i];
        if (!window->Active)
            continue;
        if (window->Flags & ImGuiWindowFlags_NoInputs)
            continue;
        if (excluding_childs && (window->Flags & ImGuiWindowFlags_ChildWindow) != 0)
            continue;

        // Using the clipped AABB so a child window will typically be clipped by its parent.
        ImRect bb(window->ClippedWindowRect.Min - g.Style.TouchExtraPadding, window->ClippedWindowRect.Max + g.Style.TouchExtraPadding);
        if (bb.Contains(pos))
            return window;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movlpd %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x6b2e4(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1738(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xe2d0
movq -0x20(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
movl -0x24(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0xe223
jmp 0xe2c2
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xe239
jmp 0xe2c2
testb $0x1, -0x11(%rbp)
je 0xe252
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0xe252
jmp 0xe2c2
movq -0x30(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movq -0x20(%rbp), %rsi
addq $0x1424, %rsi           # imm = 0x1424
callq 0xdf20
movlpd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movq -0x20(%rbp), %rsi
addq $0x1424, %rsi           # imm = 0x1424
callq 0xc7e0
movlpd %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2eb40
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2ec20
testb $0x1, %al
jne 0xe2b6
jmp 0xe2c0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe2d8
jmp 0xe2c2
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe1f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetFrontMostModalRootWindow()
static ImGuiWindow* GetFrontMostModalRootWindow()
{
    ImGuiState& g = *GImGui;
    if (!g.OpenedPopupStack.empty())
        if (ImGuiWindow* front_most_popup = g.OpenedPopupStack.back().Window)
            if (front_most_popup->Flags & ImGuiWindowFlags_Modal)
                return front_most_popup;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x6b1c1(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
callq 0x2e420
testb $0x1, %al
jne 0xe355
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
callq 0x313d0
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe353
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
je 0xe351
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe35d
jmp 0xe353
jmp 0xe355
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::End()
void ImGui::End()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    ImGui::Columns(1, "#CloseColumns");
    PopClipRect();   // inner window clip rectangle

    // Stop logging
    if (!(window->Flags & ImGuiWindowFlags_ChildWindow))    // FIXME: add more options for scope of logging
        ImGui::LogFinish();

    // Pop
    // NB: we don't clear 'window->RootWindow'. The pointer is allowed to live until the next call to Begin().
    g.CurrentWindowStack.pop_back();
    if (window->Flags & ImGuiWindowFlags_Popup)
        g.CurrentPopupStack.pop_back();
    CheckStacksSize(window, false);
    SetCurrentWindow(g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x6a681(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1758(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edx
leaq 0x4cc14(%rip), %rsi     # 0x5ba72
movl %edx, %edi
callq 0x17e80
callq 0x18470
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
jne 0xee80
callq 0x184e0
movq -0x8(%rbp), %rdi
addq $0x1760, %rdi           # imm = 0x1760
callq 0x2f540
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0xeeb1
movq -0x8(%rbp), %rdi
addq $0x1808, %rdi           # imm = 0x1808
callq 0x2f590
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x165b0
movq -0x8(%rbp), %rdi
addq $0x1760, %rdi           # imm = 0x1760
callq 0x2ef10
testb $0x1, %al
jne 0xeed2
jmp 0xeeda
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xeef1
movq -0x8(%rbp), %rdi
addq $0x1760, %rdi           # imm = 0x1760
callq 0x2ef30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16560
addq $0x20, %rsp
popq %rbp
retq