LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/test/main.cpp
// Function: intersectionTest_intersect_Test::TestBody()
TEST(intersectionTest, intersect)
{
    Circle one;
    one.x = 5;
    one.y = 5;
    one.r = 10;

    Circle two;
    two.x = 0;
    two.y = 0;
    two.r = 10;

    EXPECT_TRUE(Intersection(one, two));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movaps 0x608e(%rip), %xmm0     # 0x54530
movss 0x6076(%rip), %xmm1     # 0x54520
xorps %xmm2, %xmm2
movaps %xmm1, %xmm3
callq 0x4f454
movb %al, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
testb %al, %al
jne 0x4e573
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %rdi
callq 0xcaba
leaq 0x61d5(%rip), %rdx      # 0x546b5
leaq 0x6135(%rip), %rcx      # 0x5461c
leaq 0x6134(%rip), %r8       # 0x54622
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xeb83
movq 0x28(%rsp), %r8
leaq 0x6072(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x49, %ecx
callq 0xab58
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xac00
leaq 0x8(%rsp), %rdi
callq 0xabc6
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e551
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e561
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e573
movq %rbx, %rdi
callq 0x39b6c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xabc6
jmp 0x4e58d
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e5ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95e0
jmp 0x4e5ad
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e5bd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e5cf
movq %rbx, %rdi
callq 0x39b6c
movq %r14, %rdi
callq 0x9c50
nop
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/test/main.cpp
// Function: intersectionTest_not_intersect_Test::TestBody()
TEST(intersectionTest, not_intersect)
{
    Circle one;
    one.x = 100;
    one.y = 100;
    one.r = 10;

    Circle two;
    two.x = -100;
    two.y = -100;
    two.r = 10;

    EXPECT_FALSE(Intersection(one, two));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movaps 0x5f5a(%rip), %xmm0     # 0x54540
movaps 0x5f63(%rip), %xmm2     # 0x54550
movss 0x5f2b(%rip), %xmm1     # 0x54520
movaps %xmm1, %xmm3
callq 0x4f454
xorb $0x1, %al
movb %al, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
jne 0x4e6bb
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %rdi
callq 0xcaba
leaq 0x608d(%rip), %rdx      # 0x546b5
leaq 0x5ff3(%rip), %rcx      # 0x54622
leaq 0x5fe6(%rip), %r8       # 0x5461c
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xeb83
movq 0x28(%rsp), %r8
leaq 0x5f2a(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x58, %ecx
callq 0xab58
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xac00
leaq 0x8(%rsp), %rdi
callq 0xabc6
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e699
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e6a9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e6bb
movq %rbx, %rdi
callq 0x39b6c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xabc6
jmp 0x4e6d5
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e6f5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95e0
jmp 0x4e6f5
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e705
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e717
movq %rbx, %rdi
callq 0x39b6c
movq %r14, %rdi
callq 0x9c50
nop
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/thirdparty/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetSetUpCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
                                                        int line_num) {
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
           "make sure there is only one present at "
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x20542
testb %al, %al
jne 0x4e7f7
leaq 0x5fbd(%rip), %rdx      # 0x54704
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x204, %ecx            # imm = 0x204
callq 0x28570
movq 0x27886(%rip), %rdi     # 0x75fe8
leaq 0x5fd9(%rip), %rsi      # 0x54742
movl $0x32, %edx
callq 0x9750
movq 0x2786e(%rip), %r15     # 0x75fe8
leaq 0x5ff4(%rip), %rsi      # 0x54775
movl $0x6a, %edx
movq %r15, %rdi
callq 0x9750
testq %r14, %r14
je 0x4e7af
movq %r14, %rdi
callq 0x9240
movq 0x27846(%rip), %rdi     # 0x75fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x9750
jmp 0x4e7c7
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9bf0
movq 0x2781a(%rip), %rdi     # 0x75fe8
leaq 0x600b(%rip), %rsi      # 0x547e0
movl $0x1, %edx
callq 0x9750
movq 0x27802(%rip), %rdi     # 0x75fe8
movl %ebx, %esi
callq 0x9c20
leaq 0xc(%rsp), %rdi
callq 0x2869c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x2869c
movq %rbx, %rdi
callq 0x9c50
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/thirdparty/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
                                                           int line_num) {
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
           " please make sure there is only one present at"
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x20542
testb %al, %al
jne 0x4e8ef
leaq 0x5ec5(%rip), %rdx      # 0x54704
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x213, %ecx            # imm = 0x213
callq 0x28570
movq 0x2778e(%rip), %rdi     # 0x75fe8
leaq 0x5ee1(%rip), %rsi      # 0x54742
movl $0x32, %edx
callq 0x9750
movq 0x27776(%rip), %r15     # 0x75fe8
leaq 0x5f69(%rip), %rsi      # 0x547e2
movl $0x6f, %edx
movq %r15, %rdi
callq 0x9750
testq %r14, %r14
je 0x4e8a7
movq %r14, %rdi
callq 0x9240
movq 0x2774e(%rip), %rdi     # 0x75fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x9750
jmp 0x4e8bf
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9bf0
movq 0x27722(%rip), %rdi     # 0x75fe8
leaq 0x5f13(%rip), %rsi      # 0x547e0
movl $0x1, %edx
callq 0x9750
movq 0x2770a(%rip), %rdi     # 0x75fe8
movl %ebx, %esi
callq 0x9c20
leaq 0xc(%rsp), %rdi
callq 0x2869c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x2869c
movq %rbx, %rdi
callq 0x9c50
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/src/intersection.cpp
// Function: Intersection(Circle, Circle)
bool Intersection(Circle one, Circle two)
{
    double d = std::sqrt(pow(two.x - one.x, 2) + pow(two.y - one.y, 2));
    double buff = one.r + two.r;

    if (d == 0 && one.r == two.r) {
        return true;
    }
    if (buff >= d && (one.r + d) >= two.r && (two.r + d) >= one.r) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
subps %xmm0, %xmm2
cvtps2pd %xmm2, %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movb $0x1, %al
jne 0x4f487
jp 0x4f487
ucomiss %xmm3, %xmm1
jne 0x4f487
jp 0x4f487
retq
movaps %xmm1, %xmm2
addss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x4f49b
xorl %eax, %eax
retq
cvtss2sd %xmm1, %xmm1
movapd %xmm0, %xmm4
addsd %xmm1, %xmm4
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
ucomisd %xmm2, %xmm4
jb 0x4f498
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x4f486
jmp 0x4f498
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiIO::ImGuiIO()
ImGuiIO::ImGuiIO()
{
    // Most fields are initialized with zero
    memset(this, 0, sizeof(*this));

    DisplaySize = ImVec2(-1.0f, -1.0f);
    DeltaTime = 1.0f/60.0f;
    IniSavingRate = 5.0f;
    IniFilename = "imgui.ini";
    LogFilename = "imgui_log.txt";
    Fonts = &GImDefaultFontAtlas;
    FontGlobalScale = 1.0f;
    DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
    MousePos = ImVec2(-1,-1);
    MousePosPrev = ImVec2(-1,-1);
    MouseDoubleClickTime = 0.30f;
    MouseDoubleClickMaxDist = 6.0f;
    MouseDragThreshold = 6.0f;
    for (int i = 0; i < ImGuiKey_COUNT; i++)
        KeyMap[i] = -1;
    KeyRepeatDelay = 0.250f;
    KeyRepeatRate = 0.050f;
    UserData = NULL;

    // User functions
    RenderDrawListsFn = NULL;
    MemAllocFn = malloc;
    MemFreeFn = free;
    GetClipboardTextFn = GetClipboardTextFn_DefaultImpl;   // Platform dependent default implementations
    SetClipboardTextFn = SetClipboardTextFn_DefaultImpl;
    ImeSetInputScreenPosFn = ImeSetInputScreenPosFn_DefaultImpl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x94, %rdi
movl $0x134c, %edx           # imm = 0x134C
xorl %esi, %esi
callq 0x7210
movdqa 0x35278(%rip), %xmm0    # 0x3d2d0
movdqu %xmm0, (%rbx)
leaq 0x35635(%rip), %rax     # 0x3d698
movq %rax, 0x10(%rbx)
leaq 0x35634(%rip), %rax     # 0x3d6a2
movq %rax, 0x18(%rbx)
leaq 0x56faf(%rip), %rax     # 0x5f028
movq %rax, 0x88(%rbx)
movl $0x3f800000, 0x90(%rbx) # imm = 0x3F800000
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x98(%rbx)
movabsq $-0x407fffff40800000, %rax # imm = 0xBF800000BF800000
movq %rax, 0xe8(%rbx)
movq %rax, 0x33c(%rbx)
movabsq $0x40c000003e99999a, %rax # imm = 0x40C000003E99999A
movq %rax, 0x20(%rbx)
movl $0x40c00000, 0x28(%rbx) # imm = 0x40C00000
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x2c(%rbx)
movdqu %xmm0, 0x3c(%rbx)
movdqu %xmm0, 0x4c(%rbx)
movdqu %xmm0, 0x5c(%rbx)
movdqu %xmm0, 0x68(%rbx)
movabsq $0x3d4ccccd3e800000, %rax # imm = 0x3D4CCCCD3E800000
movq %rax, 0x78(%rbx)
movq $0x0, 0x80(%rbx)
movq 0x4cedb(%rip), %rax     # 0x54fe0
movq %rax, 0xc8(%rbx)
movq 0x4ce95(%rip), %rax     # 0x54fa8
movq %rax, 0xd0(%rbx)
leaq 0x2a(%rip), %rax        # 0x814b
movq %rax, 0xb8(%rbx)
leaq 0x30(%rip), %rax        # 0x815f
movq %rax, 0xc0(%rbx)
leaq 0xb1(%rip), %rax        # 0x81ee
movq %rax, 0xd8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetClipboardTextFn_DefaultImpl(char const*)
static void SetClipboardTextFn_DefaultImpl(const char* text)
{
    ImGuiState& g = *GImGui;
    if (g.PrivateClipboard)
    {
        ImGui::MemFree(g.PrivateClipboard);
        g.PrivateClipboard = NULL;
    }
    const char* text_end = text + strlen(text);
    g.PrivateClipboard = (char*)ImGui::MemAlloc((size_t)(text_end - text) + 1);
    memcpy(g.PrivateClipboard, text, (size_t)(text_end - text));
    g.PrivateClipboard[(int)(text_end - text)] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x4d30c(%rip), %r15     # 0x55480
movq 0x2be0(%r15), %rdi
movq %r15, %r12
testq %rdi, %rdi
je 0x81a3
decl 0x334(%r15)
callq *0xd8(%r15)
movq $0x0, 0x2be0(%r15)
movq 0x4d2dd(%rip), %r12     # 0x55480
movq %rbx, %rdi
callq 0x72e0
movq %rax, %r14
leaq 0x1(%rax), %rdi
incl 0x334(%r12)
callq *0xd0(%r12)
movq %rax, 0x2be0(%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7080
movq 0x2be0(%r15), %rax
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiIO::AddInputCharacter(unsigned short)
void ImGuiIO::AddInputCharacter(ImWchar c)
{
    const int n = ImStrlenW(InputCharacters);
    if (n + 1 < IM_ARRAYSIZE(InputCharacters))
    {
        InputCharacters[n] = c;
        InputCharacters[n+1] = '\0';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x0, 0x300(%rdi)
je 0x821d
xorl %eax, %eax
cmpw $0x0, 0x302(%rdi,%rax,2)
leaq 0x1(%rax), %rax
jne 0x8204
leal -0x1(%rax), %ecx
cmpl $0xe, %ecx
jbe 0x821f
jmp 0x8233
xorl %eax, %eax
movl %eax, %eax
movw %si, 0x300(%rdi,%rax,2)
movw $0x0, 0x302(%rdi,%rax,2)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiIO::AddInputCharactersUTF8(char const*)
void ImGuiIO::AddInputCharactersUTF8(const char* utf8_chars)
{
    // We can't pass more wchars than ImGuiIO::InputCharacters[] can hold so don't convert more
    const int wchars_buf_len = sizeof(ImGuiIO::InputCharacters) / sizeof(ImWchar);
    ImWchar wchars[wchars_buf_len];
    ImTextStrFromUtf8(wchars, wchars_buf_len, utf8_chars, NULL);
    for (int i = 0; wchars[i] != 0 && i < wchars_buf_len; i++)
        AddInputCharacter(wchars[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movl $0x11, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x82de
movzwl (%r14), %ecx
testw %cx, %cx
je 0x82d5
xorl %eax, %eax
cmpw $0x0, 0x300(%rbx)
movl $0x0, %edx
je 0x82ae
xorl %edx, %edx
cmpw $0x0, 0x302(%rbx,%rdx,2)
leaq 0x1(%rdx), %rdx
jne 0x8297
leal -0x1(%rdx), %esi
cmpl $0xe, %esi
ja 0x82c2
movl %edx, %edx
movw %cx, 0x300(%rbx,%rdx,2)
movw $0x0, 0x302(%rbx,%rdx,2)
cmpq $0xf, %rax
ja 0x82d5
movzwl -0x3e(%rbp,%rax,2), %ecx
incq %rax
testw %cx, %cx
jne 0x8286
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImTextStrFromUtf8(unsigned short*, int, char const*, char const*, char const**)
int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_text_remaining)
{
    ImWchar* buf_out = buf;
    ImWchar* buf_end = buf + buf_size;
    while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c;
        in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
        if (c == 0)
            break;
        if (c < 0x10000)    // FIXME: Losing characters that don't fit in 2 bytes
            *buf_out++ = (ImWchar)c;
    }
    *buf_out = 0;
    if (in_text_remaining)
        *in_text_remaining = in_text;
    return (int)(buf_out - buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, %r15
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,2), %rbx
addq $-0x2, %rbx
cmpq %rdi, %rbx
jbe 0x8351
movq %rcx, %r13
movq %r14, %r12
testq %r13, %r13
je 0x8319
cmpq %r13, %r15
jae 0x8354
cmpb $0x0, (%r15)
je 0x8354
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x880a
movl %eax, %eax
addq %rax, %r15
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x8354
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x834a
movw %ax, (%r12)
addq $0x2, %r12
cmpq %rbx, %r12
jb 0x830f
jmp 0x8354
movq %r14, %r12
movw $0x0, (%r12)
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x8367
movq %r15, (%rax)
subq %r14, %r12
shrq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImStrdup(char const*)
char* ImStrdup(const char *str)
{
    char *buff = (char*)ImGui::MemAlloc(strlen(str) + 1);
    IM_ASSERT(buff);
    strcpy(buff, str);
    return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x72e0
leaq 0x1(%rax), %rdi
movq 0x4cf38(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x856a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72f0
leaq 0x3513f(%rip), %rdi     # 0x3d6b0
leaq 0x3513d(%rip), %rsi     # 0x3d6b5
leaq 0x35148(%rip), %rcx     # 0x3d6c7
movl $0x30b, %edx            # imm = 0x30B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImHash(void const*, int, unsigned int)
ImU32 ImHash(const void* data, int data_size, ImU32 seed)
{
    static ImU32 crc32_lut[256] = { 0 };
    if (!crc32_lut[1])
    {
        const ImU32 polynomial = 0xEDB88320;
        for (ImU32 i = 0; i < 256; i++)
        {
            ImU32 crc = i;
            for (ImU32 j = 0; j < 8; j++)
                crc = (crc >> 1) ^ (ImU32(-int(crc & 1)) & polynomial);
            crc32_lut[i] = crc;
        }
    }

    seed = ~seed;
    ImU32 crc = seed;
    const unsigned char* current = (const unsigned char*)data;

    if (data_size > 0)
    {
        // Known size
        while (data_size--)
            crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *current++];
    }
    else
    {
        // Zero-terminated string
        while (unsigned char c = *current++)
        {
            // We support a syntax of "label###id" where only "###id" is included in the hash, and only "label" gets displayed.
            // Because this syntax is rarely used we are optimizing for the common case.
            // - If we reach ### in the string we discard the hash so far and reset to the seed.
            // - We don't do 'current += 2; continue;' after handling ### to keep the code smaller.
            if (c == '#' && current[0] == '#' && current[1] == '#')
                crc = seed;

            crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];
        }
    }
    return ~crc;
}

// Assembly:
cmpl $0x0, 0x56949(%rip)     # 0x5f084
jne 0x877a
xorl %eax, %eax
leaq 0x5693a(%rip), %rcx     # 0x5f080
movl $0x8, %r8d
movl %eax, %r9d
movl %r9d, %r10d
shrl %r10d
andl $0x1, %r9d
negl %r9d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
xorl %r10d, %r9d
decl %r8d
jne 0x874f
movl %r9d, (%rcx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x8746
notl %edx
testl %esi, %esi
jle 0x87aa
movl %esi, %ecx
xorl %esi, %esi
leaq 0x568f5(%rip), %r8      # 0x5f080
movl %edx, %eax
shrl $0x8, %eax
movzbl %dl, %edx
movzbl (%rdi,%rsi), %r9d
xorl %edx, %r9d
xorl (%r8,%r9,4), %eax
incq %rsi
movl %eax, %edx
cmpl %esi, %ecx
jne 0x878d
jmp 0x8807
movb (%rdi), %sil
testb %sil, %sil
je 0x8805
pushq %rbp
movq %rsp, %rbp
addq $0x2, %rdi
leaq 0x568bf(%rip), %rcx     # 0x5f080
movl %edx, %r8d
movl %esi, %eax
xorb $0x23, %al
movb -0x1(%rdi), %r9b
movl %r9d, %r10d
xorb $0x23, %r10b
orb %al, %r10b
jne 0x87df
cmpb $0x23, (%rdi)
cmovel %edx, %r8d
movzbl %sil, %esi
movl %r8d, %eax
shrl $0x8, %eax
movzbl %r8b, %r8d
xorl %esi, %r8d
xorl (%rcx,%r8,4), %eax
incq %rdi
movl %r9d, %esi
movl %eax, %r8d
testb %r9b, %r9b
jne 0x87c4
popq %rbp
jmp 0x8807
movl %edx, %eax
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImTextStrToUtf8(char*, int, unsigned short const*, unsigned short const*)
int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
    char* buf_out = buf;
    const char* buf_end = buf + buf_size;
    while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            *buf_out++ = (char)c;
        else
            buf_out += ImTextCharToUtf8(buf_out, (int)(buf_end-buf_out-1), c);
    }
    *buf_out = 0;
    return (int)(buf_out - buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rsi
leaq (%rdi,%rsi), %r8
decq %r8
movq %rdi, %rax
cmpq %rdi, %r8
jbe 0x8ba3
addq %rdi, %rsi
movq %rdi, %rax
testq %rcx, %rcx
sete %r9b
cmpq %rcx, %rdx
setb %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x8ba3
movzwl (%rdx), %r9d
testl %r9d, %r9d
je 0x8ba3
cmpw $0x7f, %r9w
ja 0x8ad0
movb %r9b, (%rax)
incq %rax
jmp 0x8b96
movl %eax, %r10d
notl %r10d
addl %esi, %r10d
cmpl $0x7ff, %r9d            # imm = 0x7FF
ja 0x8b07
cmpl $0x2, %r10d
jl 0x8b55
movl %r9d, %r10d
shrl $0x6, %r10d
orb $-0x40, %r10b
movb %r10b, (%rax)
movl $0x2, %r10d
movl $0x1, %r11d
jmp 0x8b87
movl %r9d, %r11d
andl $0xfc00, %r11d          # imm = 0xFC00
cmpl $0xdc00, %r11d          # imm = 0xDC00
je 0x8b55
cmpl $0xd800, %r11d          # imm = 0xD800
jne 0x8b4f
cmpl $0x4, %r10d
jl 0x8b55
movw $0x8df0, (%rax)         # imm = 0x8DF0
movl %r9d, %r10d
shrl $0x6, %r10d
andb $0x2f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x2(%rax)
movl $0x4, %r10d
movl $0x3, %r11d
jmp 0x8b87
cmpl $0x3, %r10d
jge 0x8b5a
xorl %r10d, %r10d
jmp 0x8b93
movl %r9d, %r10d
shrl $0xc, %r10d
orb $-0x20, %r10b
movb %r10b, (%rax)
movl %r9d, %r10d
shrl $0x6, %r10d
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x1(%rax)
movl $0x3, %r10d
movl $0x2, %r11d
andb $0x3f, %r9b
orb $-0x80, %r9b
movb %r9b, (%rax,%r11)
addq %r10, %rax
addq $0x2, %rdx
cmpq %r8, %rax
jb 0x8a96
movb $0x0, (%rax)
subl %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ColorConvertRGBtoHSV(float, float, float, float&, float&, float&)
void ImGui::ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v)
{
    float K = 0.f;
    if (g < b)
    {
        const float tmp = g; g = b; b = tmp;
        K = -1.f;
    }
    if (r < g)
    {
        const float tmp = r; r = g; g = tmp;
        K = -2.f / 6.f - K;
    }

    const float chroma = r - (g < b ? g : b);
    out_h = fabsf(K + (g - b) / (6.f * chroma + 1e-20f));
    out_s = chroma / (r + 1e-20f);
    out_v = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm1, %xmm3
cmpltss %xmm2, %xmm3
movss 0x3466e(%rip), %xmm4    # 0x3d39c
andps %xmm3, %xmm4
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
maxss %xmm1, %xmm2
movss 0x3465c(%rip), %xmm1    # 0x3d3a0
subss %xmm4, %xmm1
movaps %xmm0, %xmm5
cmpltss %xmm2, %xmm5
movaps %xmm5, %xmm6
andnps %xmm4, %xmm6
andps %xmm1, %xmm5
orps %xmm6, %xmm5
movaps %xmm0, %xmm1
minss %xmm2, %xmm1
maxss %xmm0, %xmm2
movaps %xmm1, %xmm0
minss %xmm3, %xmm0
movaps %xmm2, %xmm4
subss %xmm0, %xmm4
subss %xmm3, %xmm1
movss 0x34623(%rip), %xmm0    # 0x3d3a4
mulss %xmm4, %xmm0
movss 0x3461b(%rip), %xmm3    # 0x3d3a8
addss %xmm3, %xmm0
divss %xmm0, %xmm1
addss %xmm5, %xmm1
andps 0x34540(%rip), %xmm1    # 0x3d2e0
movss %xmm1, (%rdi)
addss %xmm2, %xmm3
divss %xmm3, %xmm4
movss %xmm4, (%rsi)
movss %xmm2, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ColorConvertHSVtoRGB(float, float, float, float&, float&, float&)
void ImGui::ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b)
{
    if (s == 0.0f)
    {
        // gray
        out_r = out_g = out_b = v;
        return;
    }

    h = fmodf(h, 1.0f) / (60.0f/360.0f);
    int   i = (int)h;
    float f = h - (float)i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - s * f);
    float t = v * (1.0f - s * (1.0f - f));

    switch (i)
    {
    case 0: out_r = v; out_g = t; out_b = p; break;
    case 1: out_r = q; out_g = v; out_b = p; break;
    case 2: out_r = p; out_g = v; out_b = t; break;
    case 3: out_r = p; out_g = q; out_b = v; break;
    case 4: out_r = t; out_g = p; out_b = v; break;
    case 5: default: out_r = v; out_g = p; out_b = q; break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movaps %xmm1, %xmm3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm3
jne 0x8def
jp 0x8def
movss %xmm2, (%rbx)
movss %xmm2, (%r14)
movss %xmm2, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movss 0x34599(%rip), %xmm1    # 0x3d390
movss %xmm2, -0x20(%rbp)
movss %xmm3, -0x1c(%rbp)
callq 0x78d0
movss -0x1c(%rbp), %xmm6
movss 0x3457d(%rip), %xmm5    # 0x3d390
movss -0x20(%rbp), %xmm4
divss 0x3458c(%rip), %xmm0    # 0x3d3ac
cvttss2si %xmm0, %eax
cvttps2dq %xmm0, %xmm1
cvtdq2ps %xmm1, %xmm1
subss %xmm1, %xmm0
movaps %xmm5, %xmm1
subss %xmm6, %xmm1
mulss %xmm4, %xmm1
movaps %xmm6, %xmm3
mulss %xmm0, %xmm3
movaps %xmm5, %xmm2
subss %xmm3, %xmm2
mulss %xmm4, %xmm2
cmpl $0x4, %eax
ja 0x8ec5
movaps %xmm5, %xmm3
subss %xmm0, %xmm3
mulss %xmm3, %xmm6
subss %xmm6, %xmm5
mulss %xmm4, %xmm5
leaq 0x34615(%rip), %rcx     # 0x3d480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss %xmm4, (%r15)
movss %xmm5, (%r14)
jmp 0x8ebc
movss %xmm5, (%r15)
movss %xmm1, (%r14)
jmp 0x8ea9
movss %xmm1, (%r15)
movss %xmm4, (%r14)
movss %xmm5, (%rbx)
jmp 0x8de4
movss %xmm1, (%r15)
movss %xmm2, (%r14)
movss %xmm4, (%rbx)
jmp 0x8de4
movss %xmm2, (%r15)
movss %xmm4, (%r14)
movss %xmm1, (%rbx)
jmp 0x8de4
movss %xmm4, (%r15)
movss %xmm1, (%r14)
movss %xmm2, (%rbx)
jmp 0x8de4
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImLoadFileToMemory(char const*, char const*, int*, int)
void* ImLoadFileToMemory(const char* filename, const char* file_open_mode, int* out_file_size, int padding_bytes)
{
    IM_ASSERT(filename && file_open_mode);
    if (out_file_size)
        *out_file_size = 0;

    FILE* f;
    if ((f = fopen(filename, file_open_mode)) == NULL)
        return NULL;

    long file_size_signed;
    if (fseek(f, 0, SEEK_END) || (file_size_signed = ftell(f)) == -1 || fseek(f, 0, SEEK_SET))
    {
        fclose(f);
        return NULL;
    }

    int file_size = (int)file_size_signed;
    void* file_data = ImGui::MemAlloc(file_size + padding_bytes);
    if (file_data == NULL)
    {
        fclose(f);
        return NULL;
    }
    if (fread(file_data, 1, (size_t)file_size, f) != (size_t)file_size)
    {
        fclose(f);
        ImGui::MemFree(file_data);
        return NULL;
    }
    if (padding_bytes > 0)
        memset((void *)(((char*)file_data) + file_size), 0, padding_bytes);

    fclose(f);
    if (out_file_size)
        *out_file_size = file_size;

    return file_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8ffa
testq %rsi, %rsi
je 0x8ffa
movl %ecx, %r14d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8f09
movl $0x0, (%rbx)
callq 0x78b0
testq %rax, %rax
je 0x8f31
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x78a0
testl %eax, %eax
je 0x8f46
movq %r15, %rdi
callq 0x7330
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x71e0
cmpq $-0x1, %rax
je 0x8f29
movq %rax, %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x78a0
testl %eax, %eax
jne 0x8f29
leal (%r14,%r13), %eax
movslq %eax, %rdi
movq 0x4c50b(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x8f29
movq %rax, %r12
movslq %r13d, %rdx
movq %rdx, -0x30(%rbp)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x7400
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8fd7
testl %r14d, %r14d
jle 0x8fbe
movq %r12, %rdi
addq %rcx, %rdi
movl %r14d, %edx
xorl %esi, %esi
callq 0x7210
movq %r15, %rdi
callq 0x7330
testq %rbx, %rbx
je 0x8f34
movl %r13d, (%rbx)
jmp 0x8f34
movq %r15, %rdi
callq 0x7330
movq 0x4c49a(%rip), %rax     # 0x55480
decl 0x334(%rax)
movq %r12, %rdi
callq *0xd8(%rax)
jmp 0x8f31
leaq 0x346e3(%rip), %rdi     # 0x3d6e4
leaq 0x346ad(%rip), %rsi     # 0x3d6b5
leaq 0x346f0(%rip), %rcx     # 0x3d6ff
movl $0x468, %edx            # imm = 0x468
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetInt(unsigned int, int) const
int ImGuiStorage::GetInt(ImU32 key, int default_val) const
{
    ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return default_val;
    return it->val_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movslq (%rdi), %rdx
movq 0x8(%rdi), %rdi
movq %rdi, %rcx
testq %rdx, %rdx
jle 0x90b2
movq %rdi, %rcx
movl %edx, %r9d
movl %r9d, %r8d
shrl %r8d
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rcx,%r10)
jae 0x90aa
notl %r8d
addl %r8d, %r9d
addq %r10, %rcx
addq $0x10, %rcx
movl %r9d, %r8d
movl %r8d, %r9d
testl %r8d, %r8d
jg 0x9087
shlq $0x4, %rdx
addq %rdx, %rdi
cmpq %rdi, %rcx
je 0x90c5
cmpl %esi, (%rcx)
jne 0x90c5
movl 0x8(%rcx), %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetFloat(unsigned int, float) const
float ImGuiStorage::GetFloat(ImU32 key, float default_val) const
{
    ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return default_val;
    return it->val_f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
testq %rcx, %rcx
jle 0x9109
movq %rdx, %rax
movl %ecx, %r8d
movl %r8d, %edi
shrl %edi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x9102
notl %edi
addl %edi, %r8d
addq %r9, %rax
addq $0x10, %rax
movl %r8d, %edi
movl %edi, %r8d
testl %edi, %edi
jg 0x90e1
shlq $0x4, %rcx
addq %rcx, %rdx
cmpq %rdx, %rax
je 0x911e
cmpl %esi, (%rax)
jne 0x911e
movss 0x8(%rax), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetVoidPtr(unsigned int) const
void* ImGuiStorage::GetVoidPtr(ImGuiID key) const
{
    ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return NULL;
    return it->val_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
testq %rcx, %rcx
jle 0x9161
movq %rdx, %rax
movl %ecx, %r8d
movl %r8d, %edi
shrl %edi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x915a
notl %edi
addl %edi, %r8d
addq %r9, %rax
addq $0x10, %rax
movl %r8d, %edi
movl %edi, %r8d
testl %edi, %edi
jg 0x9139
shlq $0x4, %rcx
addq %rcx, %rdx
cmpq %rdx, %rax
je 0x9177
cmpl %esi, (%rax)
jne 0x9177
movq 0x8(%rax), %rax
jmp 0x9179
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetIntRef(unsigned int, int)
int* ImGuiStorage::GetIntRef(ImGuiID key, int 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_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movl %esi, %r12d
movq %rdi, %r14
movslq (%rdi), %rdx
movq 0x8(%rdi), %r13
movq %r13, %rbx
testq %rdx, %rdx
jle 0x91cb
movq %r13, %rbx
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r12d, (%rbx,%rsi)
jae 0x91c5
notl %eax
addl %eax, %ecx
addq %rsi, %rbx
addq $0x10, %rbx
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x91a7
movq %rdx, %rax
shlq $0x4, %rax
addq %r13, %rax
cmpq %rax, %rbx
je 0x91e3
cmpl %r12d, (%rbx)
je 0x92b2
cmpq %rbx, %r13
ja 0x92c8
cmpq %rbx, %rax
jb 0x92c8
subq %r13, %rbx
movq %rbx, %r15
sarq $0x4, %r15
cmpl 0x4(%r14), %edx
jne 0x927b
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x927b
movl %r8d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4c255(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r13
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4c228(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9263
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r13, 0x8(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%r14)
movslq (%r14), %rdx
movl -0x30(%rbp), %r8d
subq %r15, %rdx
jle 0x92a1
leaq (%rbx,%r13), %rdi
addq $0x10, %rdi
addq %rbx, %r13
shlq $0x4, %rdx
movq %r13, %rsi
movl %r8d, %r15d
callq 0x7130
movl %r15d, %r8d
movq 0x8(%r14), %r13
movl %r12d, (%r13,%rbx)
movl %r8d, 0x8(%r13,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35dd9(%rip), %rdi     # 0x3f0a8
leaq 0x357ed(%rip), %rsi     # 0x3eac3
leaq 0x35de8(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movslq (%rdi), %rdx
movq 0x8(%rdi), %r12
movq %r12, %rbx
testq %rdx, %rdx
jle 0x9334
movq %r12, %rbx
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r15d, (%rbx,%rsi)
jae 0x932e
notl %eax
addl %eax, %ecx
addq %rsi, %rbx
addq $0x10, %rbx
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x9310
movq %rdx, %rax
shlq $0x4, %rax
addq %r12, %rax
cmpq %rax, %rbx
je 0x934c
cmpl %r15d, (%rbx)
je 0x9422
cmpq %rbx, %r12
ja 0x9438
cmpq %rbx, %rax
jb 0x9438
subq %r12, %rbx
movq %rbx, %r13
sarq $0x4, %r13
cmpl 0x4(%r14), %edx
jne 0x93e6
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x93e6
movss %xmm0, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4c0eb(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4c0be(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x93cd
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%r14)
movl -0x30(%rbp), %eax
movl %eax, 0x4(%r14)
movslq (%r14), %rdx
movss -0x2c(%rbp), %xmm0
subq %r13, %rdx
jle 0x9410
leaq (%r12,%rbx), %rdi
addq $0x10, %rdi
addq %rbx, %r12
shlq $0x4, %rdx
movq %r12, %rsi
movss %xmm0, -0x2c(%rbp)
callq 0x7130
movss -0x2c(%rbp), %xmm0
movq 0x8(%r14), %r12
movl %r15d, (%r12,%rbx)
movss %xmm0, 0x8(%r12,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35c69(%rip), %rdi     # 0x3f0a8
leaq 0x3567d(%rip), %rsi     # 0x3eac3
leaq 0x35c78(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq (%rdi), %rdx
movq 0x8(%rdi), %r13
movq %r13, %rbx
testq %rdx, %rdx
jle 0x94aa
movq %r13, %rbx
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r12d, (%rbx,%rsi)
jae 0x94a4
notl %eax
addl %eax, %ecx
addq %rsi, %rbx
addq $0x10, %rbx
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x9486
movq %rdx, %rax
shlq $0x4, %rax
addq %r13, %rax
cmpq %rax, %rbx
je 0x94c2
cmpl %r12d, (%rbx)
je 0x9591
cmpq %rbx, %r13
ja 0x95a7
cmpq %rbx, %rax
jb 0x95a7
subq %r13, %rbx
movq %rbx, %r15
sarq $0x4, %r15
cmpl 0x4(%r14), %edx
jne 0x955a
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x955a
movq %r8, -0x38(%rbp)
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4bf76(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r13
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4bf49(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9542
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r13, 0x8(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%r14)
movslq (%r14), %rdx
movq -0x38(%rbp), %r8
subq %r15, %rdx
jle 0x9580
leaq (%rbx,%r13), %rdi
addq $0x10, %rdi
addq %rbx, %r13
shlq $0x4, %rdx
movq %r13, %rsi
movq %r8, %r15
callq 0x7130
movq %r15, %r8
movq 0x8(%r14), %r13
movl %r12d, (%r13,%rbx)
movq %r8, 0x8(%r13,%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 0x35afa(%rip), %rdi     # 0x3f0a8
leaq 0x3550e(%rip), %rsi     # 0x3eac3
leaq 0x35b09(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %edx, %r8d
movl %esi, %r15d
movq %rdi, %r14
movslq (%rdi), %rdx
movq 0x8(%rdi), %r12
movq %r12, %r13
testq %rdx, %rdx
jle 0x9616
movq %r12, %r13
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r15d, (%r13,%rsi)
jae 0x9610
notl %eax
addl %eax, %ecx
addq %rsi, %r13
addq $0x10, %r13
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x95f1
movq %rdx, %rax
shlq $0x4, %rax
addq %r12, %rax
cmpq %rax, %r13
je 0x9634
cmpl %r15d, (%r13)
jne 0x9634
movl %r8d, 0x8(%r13)
jmp 0x96fe
cmpq %r13, %r12
ja 0x970d
cmpq %r13, %rax
jb 0x970d
subq %r12, %r13
movq %r13, %rbx
sarq $0x4, %rbx
cmpl 0x4(%r14), %edx
jne 0x96cc
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x96cc
movl %r8d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4be04(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4bdd7(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x96b4
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%r14)
movslq (%r14), %rdx
movl -0x30(%rbp), %r8d
subq %rbx, %rdx
jle 0x96f2
leaq (%r12,%r13), %rdi
addq $0x10, %rdi
addq %r13, %r12
shlq $0x4, %rdx
movq %r12, %rsi
movl %r8d, %ebx
callq 0x7130
movl %ebx, %r8d
movq 0x8(%r14), %r12
movl %r15d, (%r12,%r13)
movl %r8d, 0x8(%r12,%r13)
incl (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35994(%rip), %rdi     # 0x3f0a8
leaq 0x353a8(%rip), %rsi     # 0x3eac3
leaq 0x359a3(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movslq (%rdi), %rdx
movq 0x8(%rdi), %r15
movq %r15, %r12
testq %rdx, %rdx
jle 0x9778
movq %r15, %r12
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r14d, (%r12,%rsi)
jae 0x9772
notl %eax
addl %eax, %ecx
addq %rsi, %r12
addq $0x10, %r12
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x9754
movq %rdx, %rax
shlq $0x4, %rax
addq %r15, %rax
cmpq %rax, %r12
je 0x9799
cmpl %r14d, (%r12)
jne 0x9799
movss %xmm0, 0x8(%r12)
jmp 0x9868
cmpq %r12, %r15
ja 0x9877
cmpq %r12, %rax
jb 0x9877
subq %r15, %r12
movq %r12, %r13
sarq $0x4, %r13
cmpl 0x4(%rbx), %edx
jne 0x9831
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x9831
movss %xmm0, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4bc9f(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
movq 0x4bc72(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9819
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x8(%rbx)
movl -0x30(%rbp), %eax
movl %eax, 0x4(%rbx)
movslq (%rbx), %rdx
movss -0x2c(%rbp), %xmm0
subq %r13, %rdx
jle 0x985b
leaq (%r15,%r12), %rdi
addq $0x10, %rdi
addq %r12, %r15
shlq $0x4, %rdx
movq %r15, %rsi
movss %xmm0, -0x2c(%rbp)
callq 0x7130
movss -0x2c(%rbp), %xmm0
movq 0x8(%rbx), %r15
movl %r14d, (%r15,%r12)
movss %xmm0, 0x8(%r15,%r12)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3582a(%rip), %rdi     # 0x3f0a8
leaq 0x3523e(%rip), %rsi     # 0x3eac3
leaq 0x35839(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq (%rdi), %rdx
movq 0x8(%rdi), %r12
movq %r12, %r13
testq %rdx, %rdx
jle 0x98e9
movq %r12, %r13
movl %edx, %ecx
movl %ecx, %eax
shrl %eax
movq %rax, %rsi
shlq $0x4, %rsi
cmpl %r15d, (%r13,%rsi)
jae 0x98e3
notl %eax
addl %eax, %ecx
addq %rsi, %r13
addq $0x10, %r13
movl %ecx, %eax
movl %eax, %ecx
testl %eax, %eax
jg 0x98c4
movq %rdx, %rax
shlq $0x4, %rax
addq %r12, %rax
cmpq %rax, %r13
je 0x9907
cmpl %r15d, (%r13)
jne 0x9907
movq %r8, 0x8(%r13)
jmp 0x99d1
cmpq %r13, %r12
ja 0x99e0
cmpq %r13, %rax
jb 0x99e0
subq %r12, %r13
movq %r13, %rbx
sarq $0x4, %rbx
cmpl 0x4(%r14), %edx
jne 0x999f
leal (%rdx,%rdx), %eax
testl %edx, %edx
movl $0x4, %ecx
cmovnel %eax, %ecx
cmpl %ecx, %edx
jge 0x999f
movq %r8, -0x38(%rbp)
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rdi
shlq $0x4, %rdi
movq 0x4bb31(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4bb04(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9987
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%r14)
movslq (%r14), %rdx
movq -0x38(%rbp), %r8
subq %rbx, %rdx
jle 0x99c5
leaq (%r12,%r13), %rdi
addq $0x10, %rdi
addq %r13, %r12
shlq $0x4, %rdx
movq %r12, %rsi
movq %r8, %rbx
callq 0x7130
movq %rbx, %r8
movq 0x8(%r14), %r12
movl %r15d, (%r12,%r13)
movq %r8, 0x8(%r12,%r13)
incl (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x356c1(%rip), %rdi     # 0x3f0a8
leaq 0x350d5(%rip), %rsi     # 0x3eac3
leaq 0x356d0(%rip), %rcx     # 0x3f0c5
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9a6b
movq %rsi, %rcx
leaq 0x100(%rbx), %r14
leaq 0x389db(%rip), %rdx     # 0x4242d
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x8678
movq %rbx, %rdi
callq 0x9a90
jmp 0x9a78
movb $0x0, (%rbx)
movl $0x0, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x241e4
movq %rbx, %rdi
callq 0x74c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
cmpl $0x0, 0x104(%rdi)
jns 0x9b12
movq 0x4b9c9(%rip), %rax     # 0x55480
incl 0x334(%rax)
xorl %edi, %edi
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
movq 0x4b990(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9afb
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x108(%rbx)
movl $0x0, 0x104(%rbx)
xorl %r15d, %r15d
movl %r15d, 0x100(%rbx)
movq %rbx, %rdi
callq 0x72e0
addq %rbx, %rax
leaq -0x28(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2c, %esi
movq %r14, %rdx
callq 0x9e22
movl %r15d, 0x110(%rbx)
movl 0x100(%rbx), %eax
testl %eax, %eax
je 0x9ba3
xorl %r14d, %r14d
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x9bae
movq 0x108(%rbx), %rdi
addq %r14, %rdi
callq 0x2420e
movslq 0x100(%rbx), %rax
cmpq %rax, %r15
jge 0x9bae
movq 0x108(%rbx), %rdx
movq (%rdx,%r14), %rcx
cmpq 0x8(%rdx,%r14), %rcx
je 0x9b95
cmpb $0x2d, (%rcx)
je 0x9b95
incl 0x110(%rbx)
movl %eax, %ecx
incq %r15
addq $0x10, %r14
cmpq %rcx, %r15
jne 0x9b56
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3522b(%rip), %rdi     # 0x3ede0
leaq 0x34f07(%rip), %rsi     # 0x3eac3
leaq 0x3556d(%rip), %rcx     # 0x3f130
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x9beb
jnp 0x9c3a
callq 0x9c64
xorl %r14d, %r14d
leaq -0x20(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x100, %edx            # imm = 0x100
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x18159
movl %eax, %r15d
callq 0x9db1
testb %r15b, %r15b
je 0x9c2c
movq %rbx, %rdi
callq 0x9a90
movb $0x1, %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
leaq -0x20(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x100, %edx            # imm = 0x100
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x18159
testb %al, %al
jne 0x9c21
jmp 0x9c2c