LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: decimal_to_ternary(int)
vector<int> decimal_to_ternary(int decimal){
	vector<int> ternary;
	while (decimal>2){
		div_t val;
		val = div(decimal,3);
		ternary.push_back(val.rem);
		decimal = val.quot;
	}
	ternary.push_back(decimal);
	return ternary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0xa880
cmpl $0x2, -0xc(%rbp)
jle 0x9ee0
movl -0xc(%rbp), %edi
movl $0x3, %esi
callq 0x31f0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x14(%rbp), %rsi
callq 0xa8a0
jmp 0x9ec1
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x9e93
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5690
jmp 0x9f0c
movq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8a0
jmp 0x9eef
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x9f02
movq -0x40(%rbp), %rdi
callq 0x5690
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: check_result(char, char)
int check_result(char user_move, char comp_move){
	//Basic computer game 
	if ((user_move == 'R' && comp_move == 'S') || (user_move == 'S' && comp_move == 'P') || (user_move == 'P' && comp_move == 'R')){
		return -1;
	}
	if ((user_move == 'S' && comp_move == 'R') || (user_move == 'P' && comp_move == 'S') || (user_move == 'R' && comp_move == 'P')){
		return 1;
	}
	return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x52, %eax
jne 0x9f42
movsbl -0x6(%rbp), %eax
cmpl $0x53, %eax
je 0x9f66
movsbl -0x5(%rbp), %eax
cmpl $0x53, %eax
jne 0x9f54
movsbl -0x6(%rbp), %eax
cmpl $0x50, %eax
je 0x9f66
movsbl -0x5(%rbp), %eax
cmpl $0x50, %eax
jne 0x9f6f
movsbl -0x6(%rbp), %eax
cmpl $0x52, %eax
jne 0x9f6f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9fb5
movsbl -0x5(%rbp), %eax
cmpl $0x53, %eax
jne 0x9f81
movsbl -0x6(%rbp), %eax
cmpl $0x52, %eax
je 0x9fa5
movsbl -0x5(%rbp), %eax
cmpl $0x50, %eax
jne 0x9f93
movsbl -0x6(%rbp), %eax
cmpl $0x53, %eax
je 0x9fa5
movsbl -0x5(%rbp), %eax
cmpl $0x52, %eax
jne 0x9fae
movsbl -0x6(%rbp), %eax
cmpl $0x50, %eax
jne 0x9fae
movl $0x1, -0x4(%rbp)
jmp 0x9fb5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: convert_queue_to_state(std::deque<int, std::allocator<int>>, int)
int convert_queue_to_state(deque<int> my_state, int R){
	//Go through all the queues elements - should be exactly R
	int out = 0;
	int temp;
	for (int i =0;i< R; i++){
		//Check the top element and pop it
		temp = my_state.front() ; //Check this syntax
		my_state.pop_front();
		out = out + temp * pow(3,i);
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa048
movq -0x20(%rbp), %rdi
callq 0xa910
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x5200
cvtsi2sdl -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x18(%rbp), %esi
movl $0x3, %edi
callq 0x4d50
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9fe1
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: print_queue(std::deque<int, std::allocator<int>>)
void print_queue(deque<int> q)
{
  while (!q.empty())
  {
    cout << q.front() << " ";
    q.pop_front();
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa940
xorb $-0x1, %al
testb $0x1, %al
jne 0xa161
jmp 0xa192
movq -0x10(%rbp), %rdi
callq 0xa910
movl (%rax), %esi
movq 0x7e5d(%rip), %rdi      # 0x11fd0
callq 0x33d0
movq %rax, %rdi
leaq 0x2166(%rip), %rsi      # 0xc2e8
callq 0x3200
movq -0x10(%rbp), %rdi
callq 0x5200
jmp 0xa150
movq 0x7e37(%rip), %rdi      # 0x11fd0
movq 0x7e20(%rip), %rsi      # 0x11fc0
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: convert_user_input_to_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int convert_user_input_to_num(string valid_input,char user_input){
	int break_flag = 0;
	for(int i=0;i<valid_input.length();i++){
		if (valid_input[i] == user_input){
			break_flag = 1;
			return i-1;// -1 because I need the output as 0,1,2 for P,R,S
		}
	}
	cout << "User input bad!!! Terminating\n\n\n\n";
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3330
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xa388
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3440
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa37b
movl $0x1, -0x18(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa3a2
jmp 0xa37d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa334
movq 0x7c41(%rip), %rdi      # 0x11fd0
leaq 0x1f57(%rip), %rsi      # 0xc2ed
callq 0x3200
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: user_won(char, char)
int user_won(char user_move, char comp_move ){
	if (user_move == 'R' && comp_move =='S'){
		return 1;
	}

	else if (user_move == 'P' && comp_move =='R'){
		return 1;
	}

	else if (user_move == 'S' && comp_move =='P'){
		return 1;
	}

	else{
		return 0;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x52, %eax
jne 0xa5bb
movsbl -0x6(%rbp), %eax
cmpl $0x53, %eax
jne 0xa5bb
movl $0x1, -0x4(%rbp)
jmp 0xa5f8
movsbl -0x5(%rbp), %eax
cmpl $0x50, %eax
jne 0xa5d6
movsbl -0x6(%rbp), %eax
cmpl $0x52, %eax
jne 0xa5d6
movl $0x1, -0x4(%rbp)
jmp 0xa5f8
movsbl -0x5(%rbp), %eax
cmpl $0x53, %eax
jne 0xa5f1
movsbl -0x6(%rbp), %eax
cmpl $0x50, %eax
jne 0xa5f1
movl $0x1, -0x4(%rbp)
jmp 0xa5f8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: beating_move(char)
char beating_move(char exp_move){
	/*
	Takes in a move and returns what beats the move
	so, R -> S, S -> P, P-> R
	*/
	if (exp_move == 'R'){
		return 'P';
	}
	else if (exp_move == 'S'){
		return 'R';
	}else{
		return 'S';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x52, %eax
jne 0xa689
movb $0x50, -0x1(%rbp)
jmp 0xa69c
movsbl -0x2(%rbp), %eax
cmpl $0x53, %eax
jne 0xa698
movb $0x52, -0x1(%rbp)
jmp 0xa69c
movb $0x53, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40a00000, -0x14(%rbp) # imm = 0x40A00000
movl $0x40a00000, -0x10(%rbp) # imm = 0x40A00000
movl $0x41200000, -0xc(%rbp) # imm = 0x41200000
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x41200000, -0x18(%rbp) # imm = 0x41200000
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
movl -0x48(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm2
movss -0x68(%rbp), %xmm3
callq 0x50cb0
movb %al, -0x31(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x4f910
movq -0xc0(%rbp), %rdi
callq 0x2dd4c
movb %al, -0xb1(%rbp)
jmp 0x4eec9
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x4eed5
jmp 0x4eeeb
jmp 0x4efd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4efe9
leaq -0x88(%rbp), %rdi
callq 0xce8a
jmp 0x4eef9
leaq 0x675d(%rip), %rdx      # 0x5565d
leaq 0x66bd(%rip), %rcx      # 0x555c4
leaq 0x66bc(%rip), %r8       # 0x555ca
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xef53
jmp 0x4ef20
leaq -0xb0(%rbp), %rdi
callq 0x9220
movq %rax, %r8
leaq 0x65ed(%rip), %rdx      # 0x55523
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
movl $0x49, %ecx
callq 0xaf28
jmp 0x4ef4e
leaq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xafd0
jmp 0x4ef63
leaq -0x90(%rbp), %rdi
callq 0xaf96
leaq -0xb0(%rbp), %rdi
callq 0x9d88
leaq -0x88(%rbp), %rdi
callq 0x2ddbc
jmp 0x4efd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4efc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4efbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xaf96
leaq -0xb0(%rbp), %rdi
callq 0x9d88
leaq -0x88(%rbp), %rdi
callq 0x2ddbc
jmp 0x4efe9
leaq -0x30(%rbp), %rdi
callq 0x2e6c6
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2e6c6
movq -0x78(%rbp), %rdi
callq 0x9c00
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x42c80000, -0x14(%rbp) # imm = 0x42C80000
movl $0x42c80000, -0x10(%rbp) # imm = 0x42C80000
movl $0x41200000, -0xc(%rbp) # imm = 0x41200000
movl $0xc2c80000, -0x20(%rbp) # imm = 0xC2C80000
movl $0xc2c80000, -0x1c(%rbp) # imm = 0xC2C80000
movl $0x41200000, -0x18(%rbp) # imm = 0x41200000
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
movl -0x48(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm2
movss -0x68(%rbp), %xmm3
callq 0x50cb0
xorb $0x1, %al
movb %al, -0x31(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x4f910
movq -0xc0(%rbp), %rdi
callq 0x2dd4c
movb %al, -0xb1(%rbp)
jmp 0x4f0bb
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x4f0c7
jmp 0x4f0dd
jmp 0x4f1c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4f1db
leaq -0x88(%rbp), %rdi
callq 0xce8a
jmp 0x4f0eb
leaq 0x656b(%rip), %rdx      # 0x5565d
leaq 0x64d1(%rip), %rcx      # 0x555ca
leaq 0x64c4(%rip), %r8       # 0x555c4
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xef53
jmp 0x4f112
leaq -0xb0(%rbp), %rdi
callq 0x9220
movq %rax, %r8
leaq 0x63fb(%rip), %rdx      # 0x55523
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
movl $0x58, %ecx
callq 0xaf28
jmp 0x4f140
leaq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xafd0
jmp 0x4f155
leaq -0x90(%rbp), %rdi
callq 0xaf96
leaq -0xb0(%rbp), %rdi
callq 0x9d88
leaq -0x88(%rbp), %rdi
callq 0x2ddbc
jmp 0x4f1c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4f1bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4f1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xaf96
leaq -0xb0(%rbp), %rdi
callq 0x9d88
leaq -0x88(%rbp), %rdi
callq 0x2ddbc
jmp 0x4f1db
leaq -0x30(%rbp), %rdi
callq 0x2e6c6
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2e6c6
movq -0x78(%rbp), %rdi
callq 0x9c00
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x109a(%rip), %rsi      # 0x50390
movq %rsi, %rdi
callq 0x50360
movq %rax, -0x18(%rbp)
leaq 0x1097(%rip), %rsi      # 0x503a0
movq %rsi, %rdi
callq 0x50360
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x35(%rbp)
je 0x4f32e
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x20912
testb $0x1, %al
jne 0x4f342
jmp 0x4f347
jmp 0x4f3f9
leaq 0x635e(%rip), %rdx      # 0x556ac
leaq -0x24(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x204, %ecx            # imm = 0x204
callq 0x28940
movq -0x48(%rbp), %rdi
callq 0x2c6da
movq %rax, -0x40(%rbp)
jmp 0x4f374
movq -0x40(%rbp), %rdi
leaq 0x636b(%rip), %rsi      # 0x556ea
callq 0x95a0
movq %rax, -0x50(%rbp)
jmp 0x4f38a
movq -0x50(%rbp), %rdi
leaq 0x6388(%rip), %rsi      # 0x5571d
callq 0x95a0
movq %rax, -0x58(%rbp)
jmp 0x4f3a0
movq -0x58(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x95a0
movq %rax, -0x60(%rbp)
jmp 0x4f3b3
movq -0x60(%rbp), %rdi
leaq 0x63ca(%rip), %rsi      # 0x55788
callq 0x95a0
movq %rax, -0x68(%rbp)
jmp 0x4f3c9
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9bd0
jmp 0x4f3d7
leaq -0x24(%rbp), %rdi
callq 0x28a6c
jmp 0x4f3f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x28a6c
jmp 0x4f41c
cmpq $0x0, -0x18(%rbp)
je 0x4f40a
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x4f412
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9c00
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xf6a(%rip), %rsi       # 0x503b0
movq %rsi, %rdi
callq 0x50360
movq %rax, -0x18(%rbp)
leaq 0xf67(%rip), %rsi       # 0x503c0
movq %rsi, %rdi
callq 0x50360
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x35(%rbp)
je 0x4f47e
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x20912
testb $0x1, %al
jne 0x4f492
jmp 0x4f497
jmp 0x4f542
leaq 0x620e(%rip), %rdx      # 0x556ac
leaq -0x24(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x213, %ecx            # imm = 0x213
callq 0x28940
movq -0x48(%rbp), %rdi
callq 0x2c6da
movq %rax, %rdi
leaq 0x6222(%rip), %rsi      # 0x556ea
callq 0x95a0
movq %rax, -0x40(%rbp)
jmp 0x4f4d3
movq -0x40(%rbp), %rdi
leaq 0x62ac(%rip), %rsi      # 0x5578a
callq 0x95a0
movq %rax, -0x50(%rbp)
jmp 0x4f4e9
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x95a0
movq %rax, -0x58(%rbp)
jmp 0x4f4fc
movq -0x58(%rbp), %rdi
leaq 0x6281(%rip), %rsi      # 0x55788
callq 0x95a0
movq %rax, -0x60(%rbp)
jmp 0x4f512
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9bd0
jmp 0x4f520
leaq -0x24(%rbp), %rdi
callq 0x28a6c
jmp 0x4f542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x28a6c
jmp 0x4f565
cmpq $0x0, -0x18(%rbp)
je 0x4f553
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x4f55b
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9c00
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movlpd %xmm2, -0x3c(%rbp)
movss %xmm3, -0x34(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4dc2(%rip), %xmm1     # 0x55ac0
callq 0x9bf0
movsd %xmm0, -0x58(%rbp)
movss -0x28(%rbp), %xmm0
subss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4da2(%rip), %xmm1     # 0x55ac0
callq 0x9bf0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x9470
movsd %xmm0, -0x48(%rbp)
movss -0x8(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x50d6f
jp 0x50d6f
movss -0x8(%rbp), %xmm0
ucomiss -0x24(%rbp), %xmm0
jne 0x50d6f
jp 0x50d6f
movb $0x1, -0x1(%rbp)
jmp 0x50dbf
movsd -0x50(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jb 0x50dbb
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x48(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x50dbb
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x48(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x50dbb
movb $0x1, -0x1(%rbp)
jmp 0x50dbf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7071d(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2be0(%rax)
je 0x8dd4
movq -0x10(%rbp), %rax
movq 0x2be0(%rax), %rdi
callq 0xa760
movq -0x10(%rbp), %rax
movq $0x0, 0x2be0(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7330
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
subq %rax, %rdi
addq $0x1, %rdi
callq 0x93d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2be0(%rax)
movq -0x10(%rbp), %rax
movq 0x2be0(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
callq 0x7080
movq -0x10(%rbp), %rax
movq 0x2be0(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x300, %rdi            # imm = 0x300
callq 0x8ee0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
cmpl $0x11, %eax
jge 0x8ecc
movq -0x18(%rbp), %rax
movw -0xa(%rbp), %dx
movslq -0x10(%rbp), %rcx
movw %dx, 0x300(%rax,%rcx,2)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movw $0x0, 0x300(%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x11, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x11, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8fb0
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movzwl -0x40(%rbp,%rax,2), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
je 0x8f7d
cmpl $0x11, -0x44(%rbp)
setl %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x8f86
jmp 0x8fa3
movq -0x50(%rbp), %rdi
movslq -0x44(%rbp), %rax
movzwl -0x40(%rbp,%rax,2), %esi
callq 0x8e70
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8f60
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
addq $-0x2, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x3d(%rbp)
jae 0x901e
cmpq $0x0, -0x20(%rbp)
je 0x9011
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3d(%rbp)
jae 0x901e
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x9027
jmp 0x9076
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x3c(%rbp), %rdi
callq 0x9850
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x9050
jmp 0x9076
cmpl $0x10000, -0x3c(%rbp)   # imm = 0x10000
jae 0x9071
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x30(%rbp)
movw %cx, (%rax)
jmp 0x8fe5
movq -0x30(%rbp), %rax
movw $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x9091
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7330
movq %rax, %rdi
addq $0x1, %rdi
callq 0x93d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x938e
jmp 0x93ad
leaq 0x51f2b(%rip), %rdi     # 0x5b2c0
leaq 0x51f29(%rip), %rsi     # 0x5b2c5
movl $0x30b, %edx            # imm = 0x30B
leaq 0x51f2f(%rip), %rcx     # 0x5b2d7
callq 0x7160
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7350
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImFormatString(char*, int, char const*, ...)
int ImFormatString(char* buf, int buf_size, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    int w = vsnprintf(buf, buf_size, fmt, args);
    va_end(args);
    buf[buf_size-1] = 0;
    return (w == -1) ? buf_size : w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x95db
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x7500
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $-0x1, -0x34(%rbp)
jne 0x965d
movl -0xc(%rbp), %eax
movl %eax, -0xf4(%rbp)
jmp 0x9666
movl -0x34(%rbp), %eax
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
addq $-0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x35(%rbp)
jae 0x9d88
cmpq $0x0, -0x20(%rbp)
je 0x9d7a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x35(%rbp)
jae 0x9d88
movq -0x18(%rbp), %rax
cmpw $0x0, (%rax)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x9d91
jmp 0x9df9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x18(%rbp)
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x80, -0x34(%rbp)
jae 0x9dc7
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x9df4
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %esi
movl -0x34(%rbp), %edx
callq 0x9e20
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x9d4e
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImTextCharToUtf8(char*, int, unsigned int)
static inline int ImTextCharToUtf8(char* buf, int buf_size, unsigned int c)
{
    if (c < 0x80)
    {
        buf[0] = (char)c;
        return 1;
    }
    if (c < 0x800)
    {
        if (buf_size < 2) return 0;
        buf[0] = (char)(0xc0 + (c >> 6));
        buf[1] = (char)(0x80 + (c & 0x3f));
        return 2;
    }
    if (c >= 0xdc00 && c < 0xe000)
    {
        return 0;
    }
    if (c >= 0xd800 && c < 0xdc00)
    {
        if (buf_size < 4) return 0;
        buf[0] = (char)(0xf0 + (c >> 18));
        buf[1] = (char)(0x80 + ((c >> 12) & 0x3f));
        buf[2] = (char)(0x80 + ((c >> 6) & 0x3f));
        buf[3] = (char)(0x80 + ((c ) & 0x3f));
        return 4;
    }
    //else if (c < 0x10000)
    {
        if (buf_size < 3) return 0;
        buf[0] = (char)(0xe0 + (c >> 12));
        buf[1] = (char)(0x80 + ((c>> 6) & 0x3f));
        buf[2] = (char)(0x80 + ((c ) & 0x3f));
        return 3;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jae 0x9e4e
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9f90
cmpl $0x800, -0x18(%rbp)     # imm = 0x800
jae 0x9e9c
cmpl $0x2, -0x14(%rbp)
jge 0x9e69
movl $0x0, -0x4(%rbp)
jmp 0x9f90
movl -0x18(%rbp), %eax
shrl $0x6, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x9f90
cmpl $0xdc00, -0x18(%rbp)    # imm = 0xDC00
jb 0x9eba
cmpl $0xe000, -0x18(%rbp)    # imm = 0xE000
jae 0x9eba
movl $0x0, -0x4(%rbp)
jmp 0x9f90
cmpl $0xd800, -0x18(%rbp)    # imm = 0xD800
jb 0x9f3c
cmpl $0xdc00, -0x18(%rbp)    # imm = 0xDC00
jae 0x9f3c
cmpl $0x4, -0x14(%rbp)
jge 0x9ede
movl $0x0, -0x4(%rbp)
jmp 0x9f90
movl -0x18(%rbp), %eax
shrl $0x12, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x18(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x9f90
cmpl $0x3, -0x14(%rbp)
jge 0x9f4b
movl $0x0, -0x4(%rbp)
jmp 0x9f90
movl -0x18(%rbp), %eax
shrl $0xc, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImTextCountUtf8BytesFromChar(unsigned int)
static inline int ImTextCountUtf8BytesFromChar(unsigned int c)
{
    if (c < 0x80) return 1;
    if (c < 0x800) return 2;
    if (c >= 0xdc00 && c < 0xe000) return 0;
    if (c >= 0xd800 && c < 0xdc00) return 4;
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0xa049
movl $0x1, -0x4(%rbp)
jmp 0xa098
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0xa05b
movl $0x2, -0x4(%rbp)
jmp 0xa098
cmpl $0xdc00, -0x8(%rbp)     # imm = 0xDC00
jb 0xa076
cmpl $0xe000, -0x8(%rbp)     # imm = 0xE000
jae 0xa076
movl $0x0, -0x4(%rbp)
jmp 0xa098
cmpl $0xd800, -0x8(%rbp)     # imm = 0xD800
jb 0xa091
cmpl $0xdc00, -0x8(%rbp)     # imm = 0xDC00
jae 0xa091
movl $0x4, -0x4(%rbp)
jmp 0xa098
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
callq 0xa1d0
movss 0x50f5b(%rip), %xmm1    # 0x5b08c
movss %xmm1, -0x10(%rbp)
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0xa1d0
movss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, %ecx
shll $0x8, %ecx
movl -0xc(%rbp), %eax
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
callq 0xa1d0
movss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, %ecx
shll $0x10, %ecx
movl -0xc(%rbp), %eax
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
callq 0xa1d0
movss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xa291
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x50df0(%rip), %xmm0    # 0x5b07c
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xa2d0
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss 0x50dca(%rip), %xmm0    # 0x5b090
subss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xa2f5
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
jmp 0xa2ff
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x3c(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movss 0x50d3e(%rip), %xmm3    # 0x5b06c
mulss %xmm3, %xmm2
movss 0x50d5a(%rip), %xmm3    # 0x5b094
addss %xmm3, %xmm2
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movaps 0x50df3(%rip), %xmm1    # 0x5b140
pand %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movss 0x50d2e(%rip), %xmm1    # 0x5b094
addss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x49(%rbp)
je 0xa5ee
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xa5f7
jmp 0xa5f9
jmp 0xa618
leaq 0x50cf4(%rip), %rdi     # 0x5b2f4
leaq 0x50cbe(%rip), %rsi     # 0x5b2c5
movl $0x468, %edx            # imm = 0x468
leaq 0x50cfc(%rip), %rcx     # 0x5b30f
callq 0x7160
cmpq $0x0, -0x20(%rbp)
je 0xa629
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7910
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xa64d
movq $0x0, -0x8(%rbp)
jmp 0xa74c
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x7900
cmpl $0x0, %eax
jne 0xa68b
movq -0x30(%rbp), %rdi
callq 0x7210
movq %rax, -0x38(%rbp)
cmpq $-0x1, %rax
je 0xa68b
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7900
cmpl $0x0, %eax
je 0xa6a1
movq -0x30(%rbp), %rdi
callq 0x7390
movq $0x0, -0x8(%rbp)
jmp 0xa74c
movq -0x38(%rbp), %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rdi
callq 0x93d0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xa6d4
movq -0x30(%rbp), %rdi
callq 0x7390
movq $0x0, -0x8(%rbp)
jmp 0xa74c
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1, %esi
callq 0x7440
movslq -0x3c(%rbp), %rcx
cmpq %rcx, %rax
je 0xa70f
movq -0x30(%rbp), %rdi
callq 0x7390
movq -0x48(%rbp), %rdi
callq 0xa760
movq $0x0, -0x8(%rbp)
jmp 0xa74c
cmpl $0x0, -0x24(%rbp)
jle 0xa72b
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x7240
movq -0x30(%rbp), %rdi
callq 0x7390
cmpq $0x0, -0x20(%rbp)
je 0xa744
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xa840
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2d350
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xa81e
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xa826
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa830
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x308c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d370
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0xa8d5
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0xa8cd
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0xa8d3
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xa87b
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xa840
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2d350
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xa930
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xa93c
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa94a
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xa840
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2d350
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xa9ab
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xa9b5
movq $0x0, -0x8(%rbp)
jmp 0xa9c1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xaa1e
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xaa4a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x2d500
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xaab0
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xaade
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x2d520
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xa840
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2d370
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xab3f
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xab6c
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2d550
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2d390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)