LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/El-Duder1no[P]geometry/test/main.cpp
// Function: structFillTest_incorrectFill_Test::TestBody()
TEST(structFillTest, incorrectFill)
{
    Circle one;
    std::string text = "triangle(1.5 1.5, 3)";

    EXPECT_FALSE(structFill(one, text));

    text = "circle(56 39.5, -18)";
    EXPECT_FALSE(structFill(one, text));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
leaq 0x589c(%rip), %rsi      # 0x5367a
leaq 0x50(%rsp), %rbx
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4e21e
leaq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0x9960
leaq 0x44(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4e7d0
xorb $0x1, %al
leaq 0x38(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x9250
cmpb $0x0, -0x8(%rbx)
jne 0x4deaa
leaq 0x8(%rsp), %rdi
callq 0xc93a
leaq 0x57c2(%rip), %rdx      # 0x53606
leaq 0x57d7(%rip), %rcx      # 0x53622
leaq 0x57ca(%rip), %r8       # 0x5361c
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xea03
movq 0x10(%rsp), %r8
leaq 0x570e(%rip), %rdx      # 0x5357b
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x37
popq %rcx
callq 0xa9d8
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xaa80
movq %rsp, %rdi
callq 0xaa46
leaq 0x10(%rsp), %rdi
callq 0x9250
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4deaa
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x320ce
leaq 0x57d6(%rip), %rsi      # 0x5368f
leaq 0x50(%rsp), %rdi
callq 0x9cf0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9960
leaq 0x44(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4e7d0
movl %eax, %ebp
xorb $0x1, %al
leaq 0x38(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x70(%rsp), %rdi
callq 0x9250
testb %bpl, %bpl
je 0x4df77
leaq 0x8(%rsp), %rdi
callq 0xc93a
leaq 0x56f5(%rip), %rdx      # 0x53606
leaq 0x570a(%rip), %rcx      # 0x53622
leaq 0x56fd(%rip), %r8       # 0x5361c
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xea03
movq 0x10(%rsp), %r8
leaq 0x5641(%rip), %rdx      # 0x5357b
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x3a
popq %rcx
callq 0xa9d8
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xaa80
movq %rsp, %rdi
callq 0xaa46
leaq 0x10(%rsp), %rdi
callq 0x9250
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4df77
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x320ce
leaq 0x50(%rsp), %rdi
callq 0x9250
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4df9d
jmp 0x4dfaa
jmp 0x4dfb9
jmp 0x4dfce
movq %rax, %r14
movq %rsp, %rdi
callq 0xaa46
jmp 0x4dfad
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x9250
jmp 0x4dfbc
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dfd1
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4dfd1
movq %rax, %r14
movq %rbx, %rdi
callq 0x320ce
jmp 0x4dffe
movq %rax, %r14
leaq 0x70(%rsp), %rdi
jmp 0x4dff4
jmp 0x4dffb
jmp 0x4dffb
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x9250
jmp 0x4dffe
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x9250
movq %r14, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5512(%rip), %xmm0     # 0x53530
movss 0x54fa(%rip), %xmm1     # 0x53520
xorps %xmm2, %xmm2
movaps %xmm1, %xmm3
callq 0x4ec14
leaq 0x40(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
jne 0x4e0be
leaq 0x10(%rsp), %rdi
callq 0xc93a
leaq 0x5663(%rip), %rdx      # 0x536b5
leaq 0x55c3(%rip), %rcx      # 0x5361c
leaq 0x55c2(%rip), %r8       # 0x53622
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xea03
movq 0x18(%rsp), %r8
leaq 0x5500(%rip), %rdx      # 0x5357b
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x49
popq %rcx
callq 0xa9d8
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaa80
leaq 0x8(%rsp), %rdi
callq 0xaa46
leaq 0x18(%rsp), %rdi
callq 0x9250
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e0be
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x320ce
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xaa46
jmp 0x4e0e0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x9250
jmp 0x4e0ef
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e104
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4e104
movq %rax, %r14
movq %rbx, %rdi
callq 0x320ce
movq %r14, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x541e(%rip), %xmm0     # 0x53540
movaps 0x5427(%rip), %xmm2     # 0x53550
movss 0x53ef(%rip), %xmm1     # 0x53520
movaps %xmm1, %xmm3
callq 0x4ec14
xorb $0x1, %al
leaq 0x40(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
jne 0x4e1c8
leaq 0x10(%rsp), %rdi
callq 0xc93a
leaq 0x5559(%rip), %rdx      # 0x536b5
leaq 0x54bf(%rip), %rcx      # 0x53622
leaq 0x54b2(%rip), %r8       # 0x5361c
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xea03
movq 0x18(%rsp), %r8
leaq 0x53f6(%rip), %rdx      # 0x5357b
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x58
popq %rcx
callq 0xa9d8
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaa80
leaq 0x8(%rsp), %rdi
callq 0xaa46
leaq 0x18(%rsp), %rdi
callq 0x9250
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e1c8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x320ce
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xaa46
jmp 0x4e1ea
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x9250
jmp 0x4e1f9
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e20e
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4e20e
movq %rax, %r14
movq %rbx, %rdi
callq 0x320ce
movq %r14, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x203c2
testb %al, %al
jne 0x4e2d8
leaq 0x548e(%rip), %rdx      # 0x53704
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x204, %ecx            # imm = 0x204
callq 0x283f0
movq 0x26d59(%rip), %rdi     # 0x74fe8
leaq 0x54ac(%rip), %rsi      # 0x53742
callq 0x9580
leaq 0x54d3(%rip), %rsi      # 0x53775
movq %rax, %rdi
callq 0x9580
movq %rax, %rdi
movq %r14, %rsi
callq 0x9580
leaq 0x5524(%rip), %rsi      # 0x537e0
movq %rax, %rdi
callq 0x9580
movq %rax, %rdi
movl %ebx, %esi
callq 0x9bc0
leaq 0x4(%rsp), %rdi
callq 0x2851c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x2851c
movq %rbx, %rdi
callq 0x9be0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x203c2
testb %al, %al
jne 0x4e376
leaq 0x53f0(%rip), %rdx      # 0x53704
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x213, %ecx            # imm = 0x213
callq 0x283f0
movq 0x26cbb(%rip), %rdi     # 0x74fe8
leaq 0x540e(%rip), %rsi      # 0x53742
callq 0x9580
leaq 0x54a2(%rip), %rsi      # 0x537e2
movq %rax, %rdi
callq 0x9580
movq %rax, %rdi
movq %r14, %rsi
callq 0x9580
leaq 0x5486(%rip), %rsi      # 0x537e0
movq %rax, %rdi
callq 0x9580
movq %rax, %rdi
movl %ebx, %esi
callq 0x9bc0
leaq 0x4(%rsp), %rdi
callq 0x2851c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x2851c
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/El-Duder1no[P]geometry/thirdparty/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperFloatingPointEQ<float>(char const*, char const*, float, float)
AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
                                         const char* rhs_expression,
                                         RawType lhs_value,
                                         RawType rhs_value) {
  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);

  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  ::std::stringstream lhs_ss;
  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << lhs_value;

  ::std::stringstream rhs_ss;
  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << rhs_value;

  return EqFailure(lhs_expression,
                   rhs_expression,
                   StringStreamToString(&lhs_ss),
                   StringStreamToString(&rhs_ss),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x360, %rsp            # imm = 0x360
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
movss %xmm0, 0x4(%rsp)
movss %xmm0, (%rdi)
leaq 0x8(%rsp), %rsi
movss %xmm1, (%rsp)
movss %xmm1, (%rsi)
callq 0x3b3f2
testb %al, %al
je 0x4e3dd
movq %rbx, %rdi
callq 0xcd4b
jmp 0x4e4a0
leaq 0x1d8(%rsp), %rdi
callq 0x93d0
leaq 0x1e8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x8, 0x1f0(%rsp,%rax)
movss 0x4(%rsp), %xmm0
callq 0x9420
leaq 0x50(%rsp), %rdi
callq 0x93d0
leaq 0x60(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x8, 0x68(%rsp,%rax)
movss (%rsp), %xmm0
callq 0x9420
leaq 0x30(%rsp), %rdi
leaq 0x1d8(%rsp), %rsi
callq 0x10dc0
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x10dc0
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xe6b1
leaq 0x10(%rsp), %rdi
callq 0x9250
leaq 0x30(%rsp), %rdi
callq 0x9250
leaq 0x50(%rsp), %rdi
callq 0x9430
leaq 0x1d8(%rsp), %rdi
callq 0x9430
movq %rbx, %rax
addq $0x360, %rsp            # imm = 0x360
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9250
jmp 0x4e4c2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9250
jmp 0x4e4d3
jmp 0x4e4d0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x9430
jmp 0x4e4e4
jmp 0x4e4e1
movq %rax, %rbx
leaq 0x1d8(%rsp), %rdi
callq 0x9430
movq %rbx, %rdi
callq 0x9be0
nop
// File: /workspace/github_cpp_makefile_star2_O2/El-Duder1no[P]geometry/src/structFill.cpp
// Function: structFill(Circle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool structFill(Circle& a, std::string text)
{
    std::string x, y, r, figure;
    float xF, yF, rF;
    const char* temp;

    enter(text, figure, x, y, r);

    if (figure != "circle") {
        return false;
    }

    temp = x.c_str();
    if (isdigit(temp[0]) || temp[0] == '-') {
        xF = stof(x);
        a.x = xF;
    } else {
        return false;
    }

    temp = y.c_str();
    if (isdigit(temp[0]) || temp[0] == '-') {
        yF = stof(y);
        a.y = yF;
    } else {
        return false;
    }

    temp = r.c_str();
    if (isdigit(temp[0])) {
        rF = stof(r);
        if (rF < 0)
            return false;
        a.r = rF;
    } else {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x80(%rsp), %rdi
callq 0x9960
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
callq 0x4ea30
leaq 0x80(%rsp), %rdi
callq 0x9250
leaq 0x52a3(%rip), %rsi      # 0x53b00
leaq 0x60(%rsp), %rdi
callq 0x33da7
testb %al, %al
jne 0x4e8e3
movq 0x40(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
setne %cl
addl $-0x30, %eax
cmpl $0xa, %eax
setae %al
testb %al, %cl
jne 0x4e8e3
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x4e962
movss %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
setne %cl
addl $-0x30, %eax
cmpl $0xa, %eax
setae %al
testb %al, %cl
jne 0x4e8e3
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x4e962
movss %xmm0, 0x4(%rbx)
movq (%rsp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x4e8e3
movq %rsp, %rdi
xorl %esi, %esi
callq 0x4e962
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4e916
xorl %ebx, %ebx
leaq 0x60(%rsp), %rdi
callq 0x9250
movq %rsp, %rdi
callq 0x9250
leaq 0x20(%rsp), %rdi
callq 0x9250
leaq 0x40(%rsp), %rdi
callq 0x9250
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
movss %xmm0, 0x8(%rbx)
movb $0x1, %bl
jmp 0x4e8e5
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x9250
jmp 0x4e934
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x9250
movq %rsp, %rdi
callq 0x9250
leaq 0x20(%rsp), %rdi
callq 0x9250
leaq 0x40(%rsp), %rdi
callq 0x9250
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/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
sqrtsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movb $0x1, %al
jne 0x4ec44
jp 0x4ec44
ucomiss %xmm3, %xmm1
jne 0x4ec44
jp 0x4ec44
retq
movaps %xmm1, %xmm2
addss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x4ec58
xorl %eax, %eax
retq
cvtss2sd %xmm1, %xmm1
movapd %xmm0, %xmm4
addsd %xmm1, %xmm4
cvtss2sd %xmm3, %xmm2
ucomisd %xmm2, %xmm4
jb 0x4ec55
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x4ec43
jmp 0x4ec55
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x2c, %rdi
movl $0x13b4, %edx           # imm = 0x13B4
xorl %esi, %esi
callq 0x7210
movaps 0x2e4ae(%rip), %xmm0    # 0x362d0
movups %xmm0, (%rbx)
leaq 0x2e824(%rip), %rax     # 0x36650
movq %rax, 0x10(%rbx)
leaq 0x2e823(%rip), %rax     # 0x3665a
movq %rax, 0x18(%rbx)
leaq 0x521e6(%rip), %rax     # 0x5a028
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
pushq $0xb
popq %rax
cmpq $0x1e, %rax
je 0x7ea3
orl $-0x1, (%rbx,%rax,4)
incq %rax
jmp 0x7e94
movabsq $0x3d4ccccd3e800000, %rax # imm = 0x3D4CCCCD3E800000
movq %rax, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
andq $0x0, 0xb0(%rbx)
movq 0x48120(%rip), %rax     # 0x4ffe8
movq %rax, 0xc8(%rbx)
movq 0x480e2(%rip), %rax     # 0x4ffb8
movq %rax, 0xd0(%rbx)
leaq 0x2a(%rip), %rax        # 0x7f0e
movq %rax, 0xb8(%rbx)
leaq 0x30(%rip), %rax        # 0x7f22
movq %rax, 0xc0(%rbx)
leaq 0xae(%rip), %rax        # 0x7fae
movq %rax, 0xd8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48549(%rip), %r15     # 0x50480
movq 0x2be0(%r15), %rdi
movq %r15, %r12
testq %rdi, %rdi
je 0x7f63
decl 0x334(%r15)
callq *0xd8(%r15)
andq $0x0, 0x2be0(%r15)
movq 0x4851d(%rip), %r12     # 0x50480
movq %rbx, %rdi
callq 0x7300
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_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addq $0x300, %rbx            # imm = 0x300
movq %rbx, %rdi
callq 0x7fe7
cmpl $0xf, %eax
jg 0x7fe2
cltq
movw %r14w, (%rbx,%rax,2)
andw $0x0, 0x2(%rbx,%rax,2)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
leaq -0x40(%rbp), %rdi
pushq $0x11
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x804b
cmpq $0x10, %r14
ja 0x8042
movzwl -0x40(%rbp,%r14,2), %eax
testw %ax, %ax
je 0x8042
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x7fb4
incq %r14
jmp 0x8021
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,2), %r15
addq $-0x2, %r15
leaq -0x34(%rbp), %rbx
movq %rdi, -0x40(%rbp)
testq %r13, %r13
sete %al
cmpq %r13, %r12
setb %cl
cmpq %r15, %r14
jae 0x80c3
orb %cl, %al
je 0x80c3
cmpb $0x0, (%r12)
je 0x80c3
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x851f
movl %eax, %eax
addq %rax, %r12
movl -0x34(%rbp), %eax
testl %eax, %eax
je 0x80c3
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x807c
movw %ax, (%r14)
addq $0x2, %r14
jmp 0x807c
movq -0x30(%rbp), %rax
andw $0x0, (%r14)
testq %rax, %rax
je 0x80d4
movq %r12, (%rax)
subq -0x40(%rbp), %r14
shrq %r14
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7300
leaq 0x1(%rax), %rdi
movq 0x481fd(%rip), %rax     # 0x50480
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x82a5
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7310
leaq 0x2e3bc(%rip), %rdi     # 0x36668
leaq 0x2e3ba(%rip), %rsi     # 0x3666d
leaq 0x2e3c5(%rip), %rcx     # 0x3667f
movl $0x30b, %edx            # imm = 0x30B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x51c10(%rip)     # 0x5a084
leaq 0x51c05(%rip), %rcx     # 0x5a080
je 0x84a7
notl %edx
testl %esi, %esi
jle 0x84e5
movl %esi, %eax
xorl %esi, %esi
cmpl %esi, %eax
je 0x84a3
movzbl %dl, %r8d
shrl $0x8, %edx
movzbl (%rdi,%rsi), %r9d
xorl %r8d, %r9d
xorl (%rcx,%r9,4), %edx
incq %rsi
jmp 0x8487
movl %edx, %eax
jmp 0x851c
xorl %eax, %eax
movl $0x8, %r8d
cmpq $0x100, %rax            # imm = 0x100
je 0x847d
movl %r8d, %r10d
movl %eax, %r9d
subl $0x1, %r10d
jb 0x84dc
movl %r9d, %r11d
shrl %r11d
andl $0x1, %r9d
negl %r9d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
xorl %r11d, %r9d
jmp 0x84bd
movl %r9d, (%rcx,%rax,4)
incq %rax
jmp 0x84af
pushq %rbp
movq %rsp, %rbp
addq $0x2, %rdi
movl %edx, %eax
movzbl -0x2(%rdi), %esi
testl %esi, %esi
je 0x851b
cmpl $0x23, %esi
jne 0x8508
cmpb $0x23, -0x1(%rdi)
jne 0x8508
cmpb $0x23, (%rdi)
cmovel %edx, %eax
movzbl %al, %r8d
shrl $0x8, %eax
xorl %esi, %r8d
xorl (%rcx,%r8,4), %eax
incq %rdi
jmp 0x84ef
popq %rbp
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %rax
leaq (%rdi,%rax), %rsi
leaq -0x1(%rdi,%rax), %r8
movabsq $0x2, %r9
movabsq $0x1, %r10
movabsq $0x4, %r11
movabsq $0x3, %rbx
movq %rdi, %rax
testq %rcx, %rcx
sete %r14b
cmpq %rcx, %rdx
setb %r15b
cmpq %r8, %rax
jae 0x88b8
orb %r15b, %r14b
je 0x88b8
movzwl (%rdx), %r14d
testl %r14d, %r14d
je 0x88b8
addq $0x2, %rdx
cmpw $0x7f, %r14w
ja 0x8803
movb %r14b, (%rax)
incq %rax
jmp 0x87c3
movl %eax, %r15d
notl %r15d
addl %esi, %r15d
cmpw $0x7ff, %r14w           # imm = 0x7FF
ja 0x8830
cmpl $0x2, %r15d
jl 0x8878
movl %r14d, %r15d
shrl $0x6, %r15d
orb $-0x40, %r15b
movb %r15b, (%rax)
movq %r10, %r12
movq %r9, %r15
jmp 0x88a4
movl %r14d, %r12d
andl $0xfc00, %r12d          # imm = 0xFC00
cmpl $0xdc00, %r12d          # imm = 0xDC00
je 0x8878
cmpl $0xd800, %r12d          # imm = 0xD800
jne 0x8872
cmpl $0x4, %r15d
jl 0x8878
movw $0x8df0, (%rax)         # imm = 0x8DF0
movl %r14d, %r15d
shrl $0x6, %r15d
andb $0x2f, %r15b
orb $-0x80, %r15b
movb %r15b, 0x2(%rax)
movq %rbx, %r12
movq %r11, %r15
jmp 0x88a4
cmpl $0x3, %r15d
jge 0x887d
xorl %r15d, %r15d
jmp 0x88b0
movl %r14d, %r15d
shrl $0xc, %r15d
orb $-0x20, %r15b
movb %r15b, (%rax)
movl %r14d, %r15d
shrl $0x6, %r15d
andb $0x3f, %r15b
orb $-0x80, %r15b
movb %r15b, 0x1(%rax)
movq %r9, %r12
movq %rbx, %r15
andb $0x3f, %r14b
orb $-0x80, %r14b
movb %r14b, (%rax,%r12)
addq %r15, %rax
jmp 0x87c3
movb $0x0, (%rax)
subl %edi, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ColorConvertFloat4ToU32(ImVec4 const&)
ImU32 ImGui::ColorConvertFloat4ToU32(const ImVec4& in)
{
    ImU32 out  = ((ImU32)(ImSaturate(in.x)*255.f));
    out |= ((ImU32)(ImSaturate(in.y)*255.f) << 8);
    out |= ((ImU32)(ImSaturate(in.z)*255.f) << 16);
    out |= ((ImU32)(ImSaturate(in.w)*255.f) << 24);
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm3
movss 0x4(%rdi), %xmm4
movss 0x2d9ff(%rip), %xmm0    # 0x36390
movaps %xmm0, %xmm5
minss %xmm3, %xmm5
movss 0x2d9f8(%rip), %xmm1    # 0x36398
mulss %xmm1, %xmm5
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm3
andnps %xmm5, %xmm3
cvttss2si %xmm3, %rax
movaps %xmm0, %xmm3
minss %xmm4, %xmm3
mulss %xmm1, %xmm3
cmpltss %xmm2, %xmm4
andnps %xmm3, %xmm4
cvttss2si %xmm4, %rcx
shll $0x8, %ecx
orl %eax, %ecx
movss 0x8(%rdi), %xmm3
movaps %xmm0, %xmm4
minss %xmm3, %xmm4
mulss %xmm1, %xmm4
cmpltss %xmm2, %xmm3
andnps %xmm4, %xmm3
cvttss2si %xmm3, %rdx
shll $0x10, %edx
movss 0xc(%rdi), %xmm3
minss %xmm3, %xmm0
mulss %xmm1, %xmm0
cmpltss %xmm2, %xmm3
andnps %xmm0, %xmm3
cvttss2si %xmm3, %rax
shll $0x18, %eax
orl %edx, %eax
orl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d974(%rip), %xmm4    # 0x3639c
andps %xmm3, %xmm4
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
maxss %xmm1, %xmm2
movss 0x2d962(%rip), %xmm1    # 0x363a0
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 0x2d929(%rip), %xmm0    # 0x363a4
mulss %xmm4, %xmm0
movss 0x2d921(%rip), %xmm3    # 0x363a8
addss %xmm3, %xmm0
divss %xmm0, %xmm1
addss %xmm5, %xmm1
andps 0x2d846(%rip), %xmm1    # 0x362e0
movss %xmm1, (%rdi)
addss %xmm2, %xmm3
divss %xmm3, %xmm4
movss %xmm4, (%rsi)
movss %xmm2, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ae9
jp 0x8ae9
movss %xmm2, (%rbx)
movss %xmm2, (%r14)
movss %xmm2, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movss 0x2d89f(%rip), %xmm1    # 0x36390
movss %xmm2, -0x20(%rbp)
movss %xmm3, -0x1c(%rbp)
callq 0x78c0
movss -0x1c(%rbp), %xmm6
movss 0x2d883(%rip), %xmm5    # 0x36390
movss -0x20(%rbp), %xmm4
divss 0x2d892(%rip), %xmm0    # 0x363ac
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 0x8bbf
movaps %xmm5, %xmm3
subss %xmm0, %xmm3
mulss %xmm3, %xmm6
subss %xmm6, %xmm5
mulss %xmm4, %xmm5
leaq 0x2d91b(%rip), %rcx     # 0x36480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss %xmm4, (%r15)
movss %xmm5, (%r14)
jmp 0x8bb6
movss %xmm5, (%r15)
movss %xmm1, (%r14)
jmp 0x8ba3
movss %xmm1, (%r15)
movss %xmm4, (%r14)
movss %xmm5, (%rbx)
jmp 0x8ade
movss %xmm1, (%r15)
movss %xmm2, (%r14)
movss %xmm4, (%rbx)
jmp 0x8ade
movss %xmm2, (%r15)
movss %xmm4, (%r14)
movss %xmm1, (%rbx)
jmp 0x8ade
movss %xmm4, (%r15)
movss %xmm1, (%r14)
movss %xmm2, (%rbx)
jmp 0x8ade
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ced
testq %rsi, %rsi
je 0x8ced
movl %ecx, %r14d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8c00
andl $0x0, (%rbx)
callq 0x78a0
testq %rax, %rax
je 0x8c26
movq %rax, %r15
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x7880
testl %eax, %eax
je 0x8c3b
movq %r15, %rdi
callq 0x7350
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 0x8c1e
movq %rax, %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7880
testl %eax, %eax
jne 0x8c1e
leal (%r14,%r13), %eax
movslq %eax, %rdi
movq 0x47816(%rip), %rax     # 0x50480
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x8c1e
movq %rax, %r12
movslq %r13d, %rdx
movq %rdx, -0x30(%rbp)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rcx
callq 0x7400
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8cca
testl %r14d, %r14d
jle 0x8cb1
movq %r12, %rdi
addq %rcx, %rdi
movl %r14d, %edx
xorl %esi, %esi
callq 0x7210
movq %r15, %rdi
callq 0x7350
testq %rbx, %rbx
je 0x8c29
movl %r13d, (%rbx)
jmp 0x8c29
movq %r15, %rdi
callq 0x7350
movq 0x477a7(%rip), %rax     # 0x50480
decl 0x334(%rax)
movq %r12, %rdi
callq *0xd8(%rax)
jmp 0x8c26
leaq 0x2d9a8(%rip), %rdi     # 0x3669c
leaq 0x2d972(%rip), %rsi     # 0x3666d
leaq 0x2d9b5(%rip), %rcx     # 0x366b7
movl $0x468, %edx            # imm = 0x468
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x8d70
movslq (%r15), %rcx
shlq $0x4, %rcx
addq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x8d63
cmpl %r14d, (%rax)
jne 0x8d63
movl 0x8(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: LowerBound(ImVector<ImGuiStorage::Pair>&, unsigned int)
static ImVector<ImGuiStorage::Pair>::iterator LowerBound(ImVector<ImGuiStorage::Pair>& data, ImU32 key)
{
    ImVector<ImGuiStorage::Pair>::iterator first = data.begin();
    ImVector<ImGuiStorage::Pair>::iterator last = data.end();
    int count = (int)(last - first);
    while (count > 0)
    {
        int count2 = count / 2;
        ImVector<ImGuiStorage::Pair>::iterator mid = first + count2;
        if (mid->key < key)
        {
            first = ++mid;
            count -= count2 + 1;
        }
        else
        {
            count = count2;
        }
    }
    return first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x8d9f
movl %ecx, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %esi, (%rax,%rdi)
jae 0x8d9b
notl %edx
addl %edx, %ecx
addq %rdi, %rax
addq $0x10, %rax
movl %ecx, %edx
movl %edx, %ecx
jmp 0x8d7a
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x14(%rbp)
movl %esi, %ebx
movq %rdi, %r14
callq 0x8d70
movslq (%r14), %rcx
shlq $0x4, %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x8ddc
cmpl %ebx, (%rax)
movss -0x14(%rbp), %xmm0
jne 0x8de1
movss 0x8(%rax), %xmm0
jmp 0x8de1
movss -0x14(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x8d70
movslq (%r14), %rcx
shlq $0x4, %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x8e15
cmpl %ebx, (%rax)
jne 0x8e15
movq 0x8(%rax), %rax
jmp 0x8e17
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x8d70
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x8e4c
cmpl %r15d, (%rax)
je 0x8e62
leaq -0x28(%rbp), %rdx
movl %r15d, (%rdx)
movl %r14d, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x8, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movss %xmm0, -0x14(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
callq 0x8d70
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x8ea2
cmpl %r14d, (%rax)
je 0x8ebe
leaq -0x28(%rbp), %rdx
movl %r14d, (%rdx)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x8, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x8d70
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x8efc
cmpl %r15d, (%rax)
je 0x8f12
leaq -0x28(%rbp), %rdx
movl %r15d, (%rdx)
movq %r14, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x8, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
callq 0x8d70
movslq (%r14), %rcx
shlq $0x4, %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x8f56
cmpl %r15d, (%rax)
jne 0x8f56
movl %ebx, 0x8(%rax)
jmp 0x8f6b
leaq -0x28(%rbp), %rdx
movl %r15d, (%rdx)
movl %ebx, 0x8(%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movss %xmm0, -0x14(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
callq 0x8d70
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x8fb2
cmpl %r14d, (%rax)
jne 0x8fb2
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
jmp 0x8fce
leaq -0x28(%rbp), %rdx
movl %r14d, (%rdx)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x8d70
movslq (%r14), %rcx
shlq $0x4, %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x900e
cmpl %r15d, (%rax)
jne 0x900e
movq %rbx, 0x8(%rax)
jmp 0x9024
leaq -0x28(%rbp), %rdx
movl %r15d, (%rdx)
movq %rbx, 0x8(%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e10a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x90a9
movq %rsi, %rcx
leaq 0x100(%rbx), %r14
leaq 0x3258d(%rip), %rdx     # 0x3b61d
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x83b1
movq %rbx, %rdi
callq 0x90cc
jmp 0x90b3
movb $0x0, (%rbx)
andl $0x0, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1e1ee
movq %rbx, %rdi
callq 0x74b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x1e218
movq %rbx, %rdi
callq 0x7300
addq %rbx, %rax
leaq -0x28(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
pushq $0x2c
popq %rsi
movq %r14, %rdx
callq 0x92c8
andl $0x0, 0x110(%rbx)
cmpl (%r14), %r15d
je 0x9162
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e2ae
movq %rax, %rdi
callq 0x1e2e2
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e2ae
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x915d
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e2ae
movq (%rax), %rax
cmpb $0x2d, (%rax)
je 0x915d
incl 0x110(%rbx)
incl %r15d
jmp 0x9118
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
movss %xmm0, -0x14(%rbp)
ucomiss %xmm1, %xmm0
jne 0x918e
jnp 0x9198
movss -0x14(%rbp), %xmm0
callq 0x91e1
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9225
movl %eax, %r14d
movss -0x14(%rbp), %xmm0
ucomiss 0x2d1f1(%rip), %xmm0    # 0x363b0
jne 0x91c3
jnp 0x91c8
callq 0x9272
testb %r14b, %r14b
je 0x91d5
movq %rbx, %rdi
callq 0x90cc
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq