LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetFloatRef(unsigned int, float)
float* ImGuiStorage::GetFloatRef(ImGuiID key, float default_val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, Pair(key, default_val));
    return &it->val_f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %rbx
testq %rax, %rax
jle 0x9399
movq %rcx, %rbx
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r15d, (%rbx,%rdi)
jae 0x9393
notl %edx
addl %edx, %esi
addq %rdi, %rbx
addq $0x10, %rbx
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x9375
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %rbx
je 0x93b1
cmpl %r15d, (%rbx)
je 0x9492
cmpq %rbx, %rcx
ja 0x94a8
cmpq %rbx, %rdx
jb 0x94a8
subq %rcx, %rbx
movq %rbx, %r13
sarq $0x4, %r13
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x9453
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %r12d
cmovnel %eax, %r12d
cmpl %r12d, %ecx
jge 0x9453
movss %xmm0, -0x2c(%rbp)
movslq %r12d, %rdi
shlq $0x4, %rdi
movq 0x4c094(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9435
movq 0x4c061(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4c054(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
movl %r12d, 0x4(%r14)
movss -0x2c(%rbp), %xmm0
movslq (%r14), %rdx
subq %r13, %rdx
jle 0x947d
movq 0x8(%r14), %rsi
leaq (%rsi,%rbx), %rdi
addq $0x10, %rdi
addq %rbx, %rsi
shlq $0x4, %rdx
movss %xmm0, -0x2c(%rbp)
callq 0x7130
movss -0x2c(%rbp), %xmm0
movq 0x8(%r14), %rax
movl %r15d, (%rax,%rbx)
movss %xmm0, 0x8(%rax,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35bc9(%rip), %rdi     # 0x3f078
leaq 0x355dd(%rip), %rsi     # 0x3ea93
leaq 0x35bd8(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetVoidPtrRef(unsigned int, void*)
void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, Pair(key, default_val));
    return &it->val_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r8
movl %esi, %r12d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %rbx
testq %rax, %rax
jle 0x951a
movq %rcx, %rbx
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r12d, (%rbx,%rdi)
jae 0x9514
notl %edx
addl %edx, %esi
addq %rdi, %rbx
addq $0x10, %rbx
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x94f6
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %rbx
je 0x9532
cmpl %r12d, (%rbx)
je 0x960c
cmpq %rbx, %rcx
ja 0x9622
cmpq %rbx, %rdx
jb 0x9622
subq %rcx, %rbx
movq %rbx, %r15
sarq $0x4, %r15
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x95d2
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %r13d
cmovnel %eax, %r13d
cmpl %r13d, %ecx
jge 0x95d2
movq %r8, -0x38(%rbp)
movslq %r13d, %rdi
shlq $0x4, %rdi
movq 0x4bf14(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x95b5
movq 0x4bee1(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4bed4(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl %r13d, 0x4(%r14)
movq -0x38(%rbp), %r8
movslq (%r14), %rdx
subq %r15, %rdx
jle 0x95f8
movq 0x8(%r14), %rsi
leaq (%rsi,%rbx), %rdi
addq $0x10, %rdi
addq %rbx, %rsi
shlq $0x4, %rdx
movq %r8, %r15
callq 0x7130
movq %r15, %r8
movq 0x8(%r14), %rax
movl %r12d, (%rax,%rbx)
movq %r8, 0x8(%rax,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35a4f(%rip), %rdi     # 0x3f078
leaq 0x35463(%rip), %rsi     # 0x3ea93
leaq 0x35a5e(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r8d
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %r13
testq %rax, %rax
jle 0x9695
movq %rcx, %r13
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r15d, (%r13,%rdi)
jae 0x968f
notl %edx
addl %edx, %esi
addq %rdi, %r13
addq $0x10, %r13
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x9670
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %r13
je 0x96b3
cmpl %r15d, (%r13)
jne 0x96b3
movl %r8d, 0x8(%r13)
jmp 0x9786
cmpq %r13, %rcx
ja 0x9795
cmpq %r13, %rdx
jb 0x9795
subq %rcx, %r13
movq %r13, %r12
sarq $0x4, %r12
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x9750
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %ebx
cmovnel %eax, %ebx
cmpl %ebx, %ecx
jge 0x9750
movl %r8d, -0x2c(%rbp)
movslq %ebx, %rdi
shlq $0x4, %rdi
movq 0x4bd96(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9733
movq 0x4bd63(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4bd56(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
movl -0x2c(%rbp), %r8d
movslq (%r14), %rdx
subq %r12, %rdx
jle 0x9776
movq 0x8(%r14), %rsi
leaq (%rsi,%r13), %rdi
addq $0x10, %rdi
addq %r13, %rsi
shlq $0x4, %rdx
movl %r8d, %ebx
callq 0x7130
movl %ebx, %r8d
movq 0x8(%r14), %rax
movl %r15d, (%rax,%r13)
movl %r8d, 0x8(%rax,%r13)
incl (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x358dc(%rip), %rdi     # 0x3f078
leaq 0x352f0(%rip), %rsi     # 0x3ea93
leaq 0x358eb(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %r12
testq %rax, %rax
jle 0x9803
movq %rcx, %r12
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r14d, (%r12,%rdi)
jae 0x97fd
notl %edx
addl %edx, %esi
addq %rdi, %r12
addq $0x10, %r12
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x97df
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %r12
je 0x9824
cmpl %r14d, (%r12)
jne 0x9824
movss %xmm0, 0x8(%r12)
jmp 0x9900
cmpq %r12, %rcx
ja 0x990f
cmpq %r12, %rdx
jb 0x990f
subq %rcx, %r12
movq %r12, %r13
sarq $0x4, %r13
movl 0x4(%rbx), %ecx
cmpl %ecx, %eax
jne 0x98c5
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %r15d
cmovnel %eax, %r15d
cmpl %r15d, %ecx
jge 0x98c5
movss %xmm0, -0x2c(%rbp)
movslq %r15d, %rdi
shlq $0x4, %rdi
movq 0x4bc22(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x4, %rdx
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x98a7
movq 0x4bbef(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4bbe2(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
movss -0x2c(%rbp), %xmm0
movslq (%rbx), %rdx
subq %r13, %rdx
jle 0x98ef
movq 0x8(%rbx), %rsi
leaq (%rsi,%r12), %rdi
addq $0x10, %rdi
addq %r12, %rsi
shlq $0x4, %rdx
movss %xmm0, -0x2c(%rbp)
callq 0x7130
movss -0x2c(%rbp), %xmm0
movq 0x8(%rbx), %rax
movl %r14d, (%rax,%r12)
movss %xmm0, 0x8(%rax,%r12)
incl (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35762(%rip), %rdi     # 0x3f078
leaq 0x35176(%rip), %rsi     # 0x3ea93
leaq 0x35771(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r8
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %r13
testq %rax, %rax
jle 0x9981
movq %rcx, %r13
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r15d, (%r13,%rdi)
jae 0x997b
notl %edx
addl %edx, %esi
addq %rdi, %r13
addq $0x10, %r13
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x995c
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %r13
je 0x999f
cmpl %r15d, (%r13)
jne 0x999f
movq %r8, 0x8(%r13)
jmp 0x9a72
cmpq %r13, %rcx
ja 0x9a81
cmpq %r13, %rdx
jb 0x9a81
subq %rcx, %r13
movq %r13, %r12
sarq $0x4, %r12
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x9a3c
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %ebx
cmovnel %eax, %ebx
cmpl %ebx, %ecx
jge 0x9a3c
movq %r8, -0x38(%rbp)
movslq %ebx, %rdi
shlq $0x4, %rdi
movq 0x4baaa(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9a1f
movq 0x4ba77(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4ba6a(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
movq -0x38(%rbp), %r8
movslq (%r14), %rdx
subq %r12, %rdx
jle 0x9a62
movq 0x8(%r14), %rsi
leaq (%rsi,%r13), %rdi
addq $0x10, %rdi
addq %r13, %rsi
shlq $0x4, %rdx
movq %r8, %rbx
callq 0x7130
movq %rbx, %r8
movq 0x8(%r14), %rax
movl %r15d, (%rax,%r13)
movq %r8, 0x8(%rax,%r13)
incl (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x355f0(%rip), %rdi     # 0x3f078
leaq 0x35004(%rip), %rsi     # 0x3ea93
leaq 0x355ff(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rdi)
testq %rsi, %rsi
je 0x9b0b
movq %rsi, %rcx
leaq 0x100(%rbx), %r14
leaq 0x389be(%rip), %rdx     # 0x424b0
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x86d8
movq %rbx, %rdi
callq 0x9b30
jmp 0x9b18
movb $0x0, (%rbx)
movl $0x0, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x24510
movq %rbx, %rdi
callq 0x74d0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
movl 0x104(%rdi), %eax
testl %eax, %eax
jns 0x9bd2
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r12d, %r12d
testl %ecx, %ecx
cmovgl %ecx, %r12d
movq %r12, %rdi
shlq $0x4, %rdi
movq 0x4b91b(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x108(%rbx), %rsi
movslq 0x100(%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x9bb7
movq 0x4b8df(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4b8d2(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x108(%rbx)
movl %r12d, 0x104(%rbx)
xorl %r15d, %r15d
movl %r15d, 0x100(%rbx)
movq %rbx, %rdi
callq 0x72f0
addq %rbx, %rax
leaq -0x30(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2c, %esi
movq %r14, %rdx
callq 0x9f00
movl %r15d, 0x110(%rbx)
movl 0x100(%rbx), %eax
testl %eax, %eax
je 0x9c64
xorl %r15d, %r15d
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x9c71
movq 0x108(%rbx), %rdi
addq %r15, %rdi
callq 0x2453a
movslq 0x100(%rbx), %rax
cmpq %rax, %r12
jge 0x9c71
movq 0x108(%rbx), %rcx
movq (%rcx,%r15), %rax
cmpq 0x8(%rcx,%r15), %rax
je 0x9c55
cmpb $0x2d, (%rax)
je 0x9c55
incl 0x110(%rbx)
incq %r12
movl (%r14), %eax
addq $0x10, %r15
cmpq %rax, %r12
jne 0x9c16
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35138(%rip), %rdi     # 0x3edb0
leaq 0x34e14(%rip), %rsi     # 0x3ea93
leaq 0x3547a(%rip), %rcx     # 0x3f100
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
movss %xmm0, -0x14(%rbp)
ucomiss %xmm1, %xmm0
jne 0x9cb0
jnp 0x9cba
movss -0x14(%rbp), %xmm0
callq 0x9d0e
xorl %eax, %eax
leaq -0x1c(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x100, %edx            # imm = 0x100
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x18689
movl %eax, %r14d
movss -0x14(%rbp), %xmm0
ucomiss 0x336b4(%rip), %xmm0    # 0x3d3a0
jne 0x9cf0
jnp 0x9cf5
callq 0x9e68
testb %r14b, %r14b
je 0x9d02
movq %rbx, %rdi
callq 0x9b30
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x40(%rbp)
movl 0x100(%rdi), %r13d
testq %r13, %r13
je 0xa22b
testq %rsi, %rsi
leaq 0x3734e(%rip), %rax     # 0x414b9
cmovneq %rsi, %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
testl %r13d, %r13d
movl $0x0, %r14d
cmovgl %r13d, %r14d
movq %rdi, -0x48(%rbp)
movq 0x108(%rdi), %r12
shlq $0x4, %r14
shlq $0x4, %r13
xorl %r15d, %r15d
movl %eax, -0x2c(%rbp)
cmpq %rbx, %r14
je 0xa23e
movq (%r12,%rbx), %rdx
movq 0x8(%r12,%rbx), %rcx
cmpq %rcx, %rdx
je 0xa1da
cmpb $0x2d, (%rdx)
jne 0xa1e1
incq %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x860a
testq %rax, %rax
je 0xa1ff
movl $0x1, %eax
movl $0x0, -0x2c(%rbp)
jmp 0xa201
movl $0x4, %eax
jmp 0xa201
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x860a
testq %rax, %rax
je 0xa1ff
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movl $0x1, %eax
jmp 0xa201
xorl %eax, %eax
testb $0x3, %al
jne 0xa212
addq $0x10, %rbx
cmpq %rbx, %r13
sete %r15b
jne 0xa19b
testb $0x1, %r15b
movl -0x2c(%rbp), %eax
je 0xa22d
movq -0x48(%rbp), %rax
cmpl $0x0, 0x110(%rax)
sete %al
jmp 0xa22d
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34b6b(%rip), %rdi     # 0x3edb0
leaq 0x34847(%rip), %rsi     # 0x3ea93
leaq 0x34f10(%rip), %rcx     # 0x3f163
movl $0x31d, %edx            # imm = 0x31D
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rax
movq %rax, -0x40(%rbp)
movups (%rdx), %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x74e0
testl %eax, %eax
jle 0xa3c6
movl %eax, %r15d
movq %rbx, -0x38(%rbp)
movslq (%r14), %r13
leal (%r15,%r13), %r12d
movl 0x4(%r14), %eax
cmpl %eax, %r12d
jl 0xa318
leal (%rax,%rax), %ebx
cmpl %ebx, %r12d
cmovgl %r12d, %ebx
cmpl %ebx, %eax
jge 0xa318
movslq %ebx, %rdi
movq 0x4b1c6(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa2ff
movq 0x4b197(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4b18a(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
movl 0x4(%r14), %eax
cmpl %r12d, %eax
jge 0xa39a
testl %eax, %eax
je 0xa332
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
addl %eax, %ebx
jmp 0xa337
movl $0x8, %ebx
cmpl %r12d, %ebx
cmovlel %r12d, %ebx
cmpl %ebx, %eax
jge 0xa39a
movslq %ebx, %rdi
movq 0x4b144(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa381
movq 0x4b115(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4b108(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
movl %r12d, (%r14)
movq 0x8(%r14), %rax
leaq (%rax,%r13), %rbx
leaq (%rax,%r13), %rdi
decq %rdi
movl %r15d, %r14d
leaq 0x1(%r14), %rsi
leaq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
callq 0x74e0
movb $0x0, -0x1(%r14,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x9, (%rdi)
jge 0xa4da
movl %esi, (%rdi)
movq $0x0, 0x8(%rdi)
movss %xmm0, 0x4(%rdi)
testb %dl, %dl
je 0xa48d
xorps %xmm1, %xmm1
movups %xmm1, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
testl %esi, %esi
jle 0xa4d9
movss 0x8(%rdi), %xmm1
movl %esi, %eax
xorl %ecx, %ecx
xorps %xmm2, %xmm2
testq %rcx, %rcx
je 0xa4b1
movss 0x30(%rdi,%rcx,4), %xmm3
ucomiss %xmm2, %xmm3
jbe 0xa4b1
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm3
cvtdq2ps %xmm3, %xmm3
movss %xmm3, 0x10(%rdi,%rcx,4)
addss 0x30(%rdi,%rcx,4), %xmm1
movl $0x0, 0x30(%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xa49d
movss %xmm1, 0x8(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3322b(%rip), %rdi     # 0x3d710
leaq 0x33199(%rip), %rsi     # 0x3d685
leaq 0x33248(%rip), %rcx     # 0x3d73b
movl $0x5a2, %edx            # imm = 0x5A2
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, 0xc(%rdi)
movss 0x4(%rdi), %xmm3
movss 0x30(%rdi), %xmm4
movaps %xmm0, %xmm5
cmpless %xmm4, %xmm5
andps %xmm5, %xmm4
andnps %xmm0, %xmm5
orps %xmm4, %xmm5
movss %xmm5, 0x30(%rdi)
movss 0x34(%rdi), %xmm0
movaps %xmm1, %xmm4
cmpless %xmm0, %xmm4
andps %xmm4, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
movss %xmm4, 0x34(%rdi)
movss 0x38(%rdi), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x38(%rdi)
xorps %xmm1, %xmm1
xorl %eax, %eax
movss 0x30(%rdi,%rax,4), %xmm0
xorps %xmm2, %xmm2
testq %rax, %rax
je 0xa57a
cmpltss %xmm0, %xmm2
andps %xmm3, %xmm2
addss %xmm2, %xmm0
addss %xmm0, %xmm1
incq %rax
cmpq $0x3, %rax
jne 0xa564
movss %xmm1, 0xc(%rdi)
movss 0x8(%rdi), %xmm2
movaps %xmm1, %xmm0
cmpless %xmm2, %xmm0
andps %xmm0, %xmm2
andnps %xmm1, %xmm0
orps %xmm2, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0x1d0(%rdi), %rax
testq %rax, %rax
jle 0xa8bd
movq 0x1d8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
movl %edx, %edi
subl %esi, %edi
xorl %ecx, %ecx
testq %rdx, %rdx
cmovnel %edi, %ecx
movq %rsi, %rdi
movl %ecx, %esi
movl %eax, %edx
callq 0x8794
movq 0x4abe4(%rip), %rcx     # 0x55490
cmpl %eax, 0x1790(%rcx)
jne 0xa8bb
movb $0x1, 0x1798(%rcx)
popq %rbp
retq
leaq 0x3c2f1(%rip), %rdi     # 0x46bb5
leaq 0x341c8(%rip), %rsi     # 0x3ea93
leaq 0x34900(%rip), %rcx     # 0x3f1d2
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x270(%rdi), %rdi
callq 0x24822
movq 0x270(%rbx), %rdi
testq %rdi, %rdi
je 0xa90a
movq 0x4ab8c(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4ab7f(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq $0x0, 0x270(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa937
movq 0x4ab5f(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4ab52(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq $0x0, (%rbx)
leaq 0x258(%rbx), %rdi
callq 0x24eba
leaq 0x1d0(%rbx), %rdi
callq 0x24794
leaq 0x1c0(%rbx), %rdi
callq 0x24d40
leaq 0x168(%rbx), %rdi
callq 0x24d6a
leaq 0x158(%rbx), %rdi
callq 0x24d94
leaq 0x148(%rbx), %rdi
callq 0x24d94
leaq 0x138(%rbx), %rdi
callq 0x24d40
leaq 0x128(%rbx), %rdi
callq 0x24d40
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24cc2
movq %rax, %rdi
callq 0x2487f
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq %rsi, -0x8(%rbp)
movslq 0x1d0(%rdi), %rax
testq %rax, %rax
jle 0xaa31
movq 0x1d8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %edx
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x8794
movq 0x4aa74(%rip), %rcx     # 0x55490
cmpl %eax, 0x1790(%rcx)
jne 0xaa2b
movb $0x1, 0x1798(%rcx)
addq $0x10, %rsp
popq %rbp
retq
leaq 0x3c17d(%rip), %rdi     # 0x46bb5
leaq 0x34054(%rip), %rsi     # 0x3ea93
leaq 0x3478c(%rip), %rcx     # 0x3f1d2
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x4a9f1(%rip), %rax     # 0x55490
movl %edi, 0x1790(%rax)
movw $0x1, 0x1799(%rax)
movq %rsi, 0x17a0(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x4a9ce(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0xabd7
movss 0xc8(%rax), %xmm2
movss 0x4(%rdi), %xmm3
movaps %xmm3, %xmm1
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm3, %xmm1
orps %xmm2, %xmm1
movss 0xcc(%rax), %xmm3
movaps %xmm0, %xmm2
cmpless %xmm3, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
movss 0x18(%rax), %xmm0
movss 0xa8(%rax), %xmm4
addss (%rdi), %xmm4
movss 0xac(%rax), %xmm5
movss %xmm4, 0xb0(%rax)
movss %xmm5, 0xb4(%rax)
addss 0x194(%rax), %xmm0
orps %xmm3, %xmm2
addss 0x198(%rax), %xmm0
cvttps2dq %xmm0, %xmm0
movaps %xmm1, %xmm3
addss %xmm5, %xmm3
addss 0x1418(%rcx), %xmm3
cvtdq2ps %xmm0, %xmm0
cvttps2dq %xmm3, %xmm3
cvtdq2ps %xmm3, %xmm3
movss %xmm0, 0xa8(%rax)
movss %xmm3, 0xac(%rax)
movss 0xc0(%rax), %xmm0
movaps %xmm4, %xmm5
cmpless %xmm0, %xmm5
movaps %xmm5, %xmm6
andnps %xmm4, %xmm6
andps %xmm0, %xmm5
orps %xmm6, %xmm5
movss %xmm5, 0xc0(%rax)
movss 0xc4(%rax), %xmm0
movaps %xmm3, %xmm4
cmpless %xmm0, %xmm4
movaps %xmm4, %xmm5
andnps %xmm3, %xmm5
andps %xmm0, %xmm4
orps %xmm5, %xmm4
movss %xmm4, 0xc4(%rax)
movss %xmm1, 0xd0(%rax)
movss %xmm2, 0xd4(%rax)
movq $0x0, 0xc8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ItemAdd(ImRect const&, unsigned int const*)
bool ImGui::ItemAdd(const ImRect& bb, const ImGuiID* id)
{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.LastItemID = id ? *id : 0;
    window->DC.LastItemRect = bb;
    if (IsClippedEx(bb, id, false))
    {
        window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
        return false;
    }

    // This is a sensible default, but widgets are free to override it after calling ItemAdd()
    ImGuiState& g = *GImGui;
    if (IsMouseHoveringRect(bb.Min, bb.Max))
    {
        // Matching the behavior of IsHovered() but ignore if ActiveId==window->MoveID (we clicked on the window background)
        // So that clicking on items with no active id such as Text() still returns true with IsItemHovered()
        window->DC.LastItemHoveredRect = true;
        window->DC.LastItemHoveredAndUsable = false;
        if (g.HoveredRootWindow == window->RootWindow)
            if (g.ActiveId == 0 || (id && g.ActiveId == *id) || g.ActiveIdIsFocusedOnly || (g.ActiveId == window->MoveID))
                if (IsWindowContentHoverable(window))
                    window->DC.LastItemHoveredAndUsable = true;
    }
    else
    {
        window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x4a86c(%rip), %r13     # 0x55490
movq 0x1758(%r13), %r12
movb $0x1, 0x72(%r12)
testq %rsi, %rsi
je 0xac3b
movl (%r14), %eax
jmp 0xac3d
xorl %eax, %eax
movl %eax, 0xe0(%r12)
movups (%r15), %xmm0
movups %xmm0, 0xe4(%r12)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xad15
movl %eax, %ebx
testb %al, %al
jne 0xace9
leaq 0x8(%r15), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0xad80
testb %al, %al
je 0xace9
movw $0x100, 0xf4(%r12) # imm = 0x100
movq 0x278(%r12), %rax
cmpq %rax, 0x1780(%r13)
jne 0xacf4
movl 0x1790(%r13), %ecx
testl %ecx, %ecx
je 0xacc0
testq %r14, %r14
je 0xacaf
cmpl (%r14), %ecx
je 0xacc0
cmpb $0x0, 0x179a(%r13)
jne 0xacc0
cmpl 0x48(%r12), %ecx
jne 0xacf4
movq 0x1770(%r13), %rcx
testq %rcx, %rcx
je 0xacde
movq 0x278(%rcx), %rcx
testq %rcx, %rcx
je 0xacde
testb $0x2, 0xf(%rcx)
jne 0xad08
movb $0x1, 0xf4(%r12)
jmp 0xacf4
movw $0x0, 0xf4(%r12)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rax, %rcx
je 0xacde
cmpb $0x0, 0x71(%rcx)
jne 0xacf4
jmp 0xacde
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x4a770(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movss 0xc(%rdi), %xmm0
ucomiss 0x1e4(%rax), %xmm0
jbe 0xad5e
movss 0x1ec(%rax), %xmm0
ucomiss 0x4(%rdi), %xmm0
jbe 0xad5e
movss 0x8(%rdi), %xmm0
ucomiss 0x1e0(%rax), %xmm0
jbe 0xad5e
movss 0x1e8(%rax), %xmm0
ucomiss (%rdi), %xmm0
ja 0xad7c
testq %rsi, %rsi
je 0xad6d
movl (%rsi), %eax
cmpl 0x1790(%rcx), %eax
je 0xad7c
movb $0x1, %al
testb %dl, %dl
jne 0xad7e
cmpb $0x1, 0x2be8(%rcx)
jne 0xad7e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x4a705(%rip), %rax     # 0x55490
movss (%rdi), %xmm3
movss 0x4(%rdi), %xmm1
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm0
testl %edx, %edx
je 0xade4
movq 0x1758(%rax), %rcx
movss 0x1e0(%rcx), %xmm4
movss 0x1e4(%rcx), %xmm5
maxss %xmm3, %xmm4
maxss %xmm1, %xmm5
movss 0x1e8(%rcx), %xmm6
minss %xmm2, %xmm6
movss 0x1ec(%rcx), %xmm7
minss %xmm0, %xmm7
movaps %xmm4, %xmm3
movaps %xmm5, %xmm1
movaps %xmm6, %xmm2
movaps %xmm7, %xmm0
movss 0x1424(%rax), %xmm5
subss %xmm5, %xmm3
movss 0xf0(%rax), %xmm4
ucomiss %xmm3, %xmm4
jae 0xae01
xorl %eax, %eax
jmp 0xae34
movss 0x1428(%rax), %xmm3
addss %xmm3, %xmm0
addss %xmm5, %xmm2
subss %xmm3, %xmm1
movss 0xf4(%rax), %xmm3
cmpltps %xmm2, %xmm4
cmpleps %xmm3, %xmm1
andps %xmm4, %xmm1
ucomiss %xmm3, %xmm0
movd %xmm1, %ecx
seta %al
andb %cl, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x4a64d(%rip), %rbx     # 0x55490
movl 0x1788(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl %esi, %eax
setne %al
testb %al, %cl
jne 0xaee7
movq 0x1758(%rbx), %rax
cmpq %rax, 0x1778(%rbx)
je 0xae7f
testb %dl, %dl
je 0xaee7
movq 0x1780(%rbx), %rcx
cmpq 0x278(%rax), %rcx
jne 0xaee7
movl 0x1790(%rbx), %eax
testl %eax, %eax
sete %cl
cmpl %esi, %eax
sete %al
orb %cl, %al
jne 0xae9c
cmpb $0x1, 0x179a(%rbx)
jne 0xaee7
leaq 0x8(%rdi), %rsi
movl $0x1, %edx
callq 0xad80
testb %al, %al
je 0xaee7
movq 0x1770(%rbx), %rcx
movb $0x1, %al
testq %rcx, %rcx
je 0xaee9
movq 0x278(%rcx), %rcx
testq %rcx, %rcx
je 0xaee9
testb $0x2, 0xf(%rcx)
je 0xaee9
cmpb $0x1, 0x71(%rcx)
jne 0xaee9
movq 0x1780(%rbx), %rax
cmpq 0x278(%rax), %rcx
sete %al
jmp 0xaee9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x4a58b(%rip), %r15     # 0x55490
movb 0x124(%rdi), %r14b
incl 0x288(%rdi)
cmpb $0x1, %r14b
jne 0xaf1e
incl 0x28c(%rbx)
testb %dl, %dl
je 0xaf7c
cmpl $0x7fffffff, 0x298(%rbx) # imm = 0x7FFFFFFF
jne 0xaf7c
cmpl $0x7fffffff, 0x29c(%rbx) # imm = 0x7FFFFFFF
setne %al
xorb $0x1, %sil
orb %al, %sil
jne 0xaf7c
movl 0x34(%r15), %edi
movl $0x1, %r12d
movl $0x1, %esi
callq 0xf076
testb %al, %al
je 0xaf7c
movzbl %r14b, %eax
negl %eax
cmpb $0x0, 0x106(%r15)
cmovnel %eax, %r12d
addl 0x28c(%rbx), %r12d
movl %r12d, 0x29c(%rbx)
movl 0x288(%rbx), %ecx
movb $0x1, %al
cmpl 0x290(%rbx), %ecx
je 0xafa1
testb %r14b, %r14b
je 0xaf9f
movl 0x28c(%rbx), %ecx
cmpl 0x294(%rbx), %ecx
je 0xafa1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movaps %xmm0, %xmm3
movq 0x4a4bf(%rip), %rbx     # 0x55490
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
ja 0xafe8
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
xorps %xmm5, %xmm5
ucomiss %xmm4, %xmm0
jbe 0xb023
movq 0x1758(%rbx), %r14
movaps %xmm3, -0x40(%rbp)
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0xb0a3
movaps -0x20(%rbp), %xmm1
movaps -0x30(%rbp), %xmm2
movaps -0x40(%rbp), %xmm3
movss 0x18(%r14), %xmm5
addss %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0x1c(%r14), %xmm0
unpcklps %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
jb 0xb058
ucomiss %xmm0, %xmm3
jne 0xb032
jnp 0xb054
movq 0x1758(%rbx), %rax
movss 0xa8(%rax), %xmm4
movaps %xmm5, %xmm1
subss %xmm4, %xmm1
maxss 0x32354(%rip), %xmm1    # 0x3d3a4
addss %xmm3, %xmm1
movss %xmm1, %xmm3            # xmm3 = xmm1[0],xmm3[1,2,3]
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
ucomiss %xmm4, %xmm0
jb 0xb097
ucomiss %xmm0, %xmm4
jne 0xb06b
jnp 0xb08d
shufps $0x55, %xmm5, %xmm5     # xmm5 = xmm5[1,1,1,1]
movq 0x1758(%rbx), %rax
subss 0xac(%rax), %xmm5
maxss 0x3231e(%rip), %xmm5    # 0x3d3a4
addss %xmm5, %xmm4
movaps %xmm4, %xmm2
movlhps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm2     # xmm2 = xmm2[2,0],xmm3[2,3]
movaps %xmm2, %xmm3
movaps %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x18, %rsp
movq 0x4a3dd(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rbx
movss 0x38(%rbx), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0xb0d3
jp 0xb0d3
movss 0x20(%rbx), %xmm2
subss 0x68(%rbx), %xmm2
movss 0x3c(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0xb0e9
jp 0xb0e9
movss 0x24(%rbx), %xmm0
subss 0x6c(%rbx), %xmm0
subss 0x4c(%rbx), %xmm2
subss 0x50(%rbx), %xmm0
subss 0x40(%rbx), %xmm2
subss 0x44(%rbx), %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
cmpl $0x1, 0x1a0(%rbx)
je 0xb127
movl 0x19c(%rbx), %edi
incl %edi
movaps %xmm2, -0x20(%rbp)
callq 0x158dd
movaps -0x20(%rbp), %xmm2
subss 0x40(%rbx), %xmm0
movss %xmm0, %xmm2            # xmm2 = xmm0[0],xmm2[1,2,3]
movaps %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0xb195
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4a346(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xb168
jp 0xb168
callq 0xb0a3
addss 0x18(%r14), %xmm0
jmp 0xb17a
jbe 0xb17a
movss 0x18(%r14), %xmm1
subss 0x4c(%r14), %xmm1
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xb191
subss (%rbx), %xmm0
maxss 0x3221a(%rip), %xmm0    # 0x3d3a8
movaps %xmm0, %xmm1
popq %rbx
popq %r14
popq %rbp
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0xc208
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc208
movss 0x4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc227
movq 0x492d3(%rip), %rcx     # 0x55490
movq %rdi, 0x1710(%rcx)
movss 0x98(%rcx), %xmm2
mulss (%rdi), %xmm2
mulss %xmm2, %xmm0
movss %xmm0, 0x171c(%rcx)
movq 0x1758(%rcx), %rdx
testq %rdx, %rdx
je 0xc1f3
mulss 0x268(%rdx), %xmm0
movaps %xmm0, %xmm1
movss %xmm1, 0x1718(%rcx)
movq 0x24(%rax), %rax
movq %rax, 0x1720(%rcx)
popq %rbp
retq
leaq 0x32b46(%rip), %rdi     # 0x3ed55
leaq 0x3146f(%rip), %rsi     # 0x3d685
leaq 0x32b51(%rip), %rcx     # 0x3ed6e
movl $0x1067, %edx           # imm = 0x1067
callq 0x7140
leaq 0x32b5e(%rip), %rdi     # 0x3ed8c
leaq 0x31450(%rip), %rsi     # 0x3d685
leaq 0x32b32(%rip), %rcx     # 0x3ed6e
movl $0x1068, %edx           # imm = 0x1068
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x49043(%rip), %rcx     # 0x55490
movslq 0x1738(%rcx), %rdx
testq %rdx, %rdx
jle 0xc51d
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movq 0x1740(%rcx), %rsi
incq %rdx
movq -0x10(%rsi,%rdx,8), %r8
movl $0x4, %r9d
cmpb $0x1, 0x70(%r8)
jne 0xc50a
movl 0xc(%r8), %r10d
btl $0x9, %r10d
jb 0xc50a
shrl $0x14, %r10d
testb %dil, %r10b
jne 0xc50a
movss 0x1f0(%r8), %xmm3
movss 0x1424(%rcx), %xmm2
subss %xmm2, %xmm3
ucomiss %xmm3, %xmm0
jae 0xc4b7
xorl %r9d, %r9d
jmp 0xc4ff
movss 0x1428(%rcx), %xmm3
movss 0x1fc(%r8), %xmm4
addss %xmm3, %xmm4
addss 0x1f8(%r8), %xmm2
movss 0x1f4(%r8), %xmm5
subss %xmm3, %xmm5
movaps %xmm0, %xmm3
cmpltps %xmm2, %xmm3
cmpleps %xmm1, %xmm5
andps %xmm3, %xmm5
ucomiss %xmm1, %xmm4
movd %xmm5, %r10d
seta %r9b
andb %r10b, %r9b
movzbl %r9b, %r9d
testb %r9b, %r9b
cmovneq %r8, %rax
testb $0x3, %r9b
jne 0xc51f
decq %rdx
cmpq $0x1, %rdx
jg 0xc46e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x48f68(%rip), %rax     # 0x55490
movl 0x17f8(%rax), %ecx
testq %rcx, %rcx
je 0xc552
testl %ecx, %ecx
jle 0xc555
movq 0x1800(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movq -0x20(%rax,%rcx,8), %rax
testq %rax, %rax
je 0xc552
testb $0x4, 0xf(%rax)
jne 0xc554
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3a655(%rip), %rdi     # 0x46bb5
leaq 0x3252c(%rip), %rsi     # 0x3ea93
leaq 0x326c1(%rip), %rcx     # 0x3ec2f
movl $0x326, %edx            # imm = 0x326
callq 0x7140