LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %dl
je 0x5179
movq (%rdi), %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb %sil, (%rdi)
je 0x5179
leaq -0x1(%rcx), %rdx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x5177
leaq 0x1(%r8), %rax
cmpb %sil, 0x1(%rdi,%r8)
movq %rax, %r8
jne 0x515a
cmpq %rax, %rcx
seta %dl
decl %eax
jmp 0x5179
xorl %edx, %edx
testb %dl, %dl
jne 0x519a
movq 0x3e4c(%rip), %rdi      # 0x8fd0
leaq 0x1176(%rip), %rsi      # 0x6301
movl $0x21, %edx
callq 0x21f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: draw_sample(int*, float)
int draw_sample(int trans_counts[],float prior_count){
	/*
	TO DO::
	Takes in a distribution and draws a random variable from that distribution
	
	@params: dist contains the number of transitions. Need not be integer.
	Returns: A character number : 1[P],2[R],3[S]
	*/
	int trans_counts_len = 1+(sizeof(trans_counts)/sizeof(*trans_counts));
	float summed_trans[trans_counts_len+1];
	summed_trans[0] = 0;
 	for (int i=0;i<trans_counts_len;i++){
		summed_trans[i+1] = summed_trans[i] + trans_counts[i] + prior_count;
	}

	//Test the computed
	// print_array(summed_trans,trans_counts_len + 1);
	// print_array(trans_counts,trans_counts_len);
	//Generate a random number
    random_device rd;  //Will be used to obtain a seed for the random number engine
    mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    uniform_real_distribution<> dis(0,1);

	float rand_number = dis(gen);
	rand_number = rand_number * summed_trans[trans_counts_len];
	//Get the lower bound of the nearest element
	int pos = lower_bound(summed_trans,summed_trans+ trans_counts_len + 1,rand_number) - summed_trans;

	return pos;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2728, %rsp           # imm = 0x2728
movl $0x0, -0x20(%rbp)
xorps %xmm1, %xmm1
movl $0x1, %eax
xorps %xmm2, %xmm2
cvtsi2ssl -0x4(%rdi,%rax,4), %xmm2
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, -0x20(%rbp,%rax,4)
incq %rax
movaps %xmm2, %xmm1
cmpq $0x4, %rax
jne 0x51b7
leaq -0x2730(%rbp), %rbx
movq %rbx, %rdi
callq 0x3c3a
movq %rbx, %rdi
callq 0x2230
movl %eax, %eax
movq %rax, -0x13a8(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x13a8(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x51ff
leaq -0x13a8(%rbp), %rdi
movq $0x270, 0x1380(%rdi) # imm = 0x270
callq 0x5782
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leaq -0x20(%rbp), %rbx
mulss 0xc(%rbx), %xmm0
movl $0x4, %ecx
movq %rcx, %rax
shrq %rax
ucomiss (%rbx,%rax,4), %xmm0
jbe 0x526e
leaq (%rbx,%rax,4), %rbx
addq $0x4, %rbx
notq %rax
addq %rcx, %rax
movq %rax, %rcx
testq %rax, %rax
jg 0x5257
leaq -0x2730(%rbp), %rdi
callq 0x2190
leaq -0x20(%rbp), %rax
subq %rax, %rbx
shrq $0x2, %rbx
movl %ebx, %eax
addq $0x2728, %rsp           # imm = 0x2728
popq %rbx
popq %rbp
retq
jmp 0x52b4
jmp 0x529d
movq %rax, %rbx
leaq -0x2730(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x3cb7
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edi, %ecx
xorb $0x52, %cl
movl %esi, %edx
xorb $0x53, %dl
movl $0x1, %eax
orb %cl, %dl
je 0x52f1
movl %edi, %ecx
xorb $0x50, %cl
movl %esi, %edx
xorb $0x52, %dl
orb %cl, %dl
je 0x52f1
xorb $0x53, %dil
xorb $0x50, %sil
xorl %eax, %eax
orb %dil, %sil
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/El-Duder1no[P]geometry/test/main.cpp
// Function: perimeterTest_correctInput_Test::TestBody()
TEST(perimeterTest, correctInput)
{
    Circle one;

    one.r = 5;
    EXPECT_FLOAT_EQ(31.415, Perimeter(one));

    one.r = 1337.322;
    EXPECT_FLOAT_EQ(8402.3945, Perimeter(one));

    one.r = 0.005;
    EXPECT_FLOAT_EQ(0.031415, Perimeter(one));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss 0x6d0b(%rip), %xmm1     # 0x544f0
callq 0x4ee58
movaps %xmm0, %xmm1
leaq 0x6d95(%rip), %rsi      # 0x54589
leaq 0x6d95(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6cec(%rip), %xmm0     # 0x544f4
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4d874
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d82c
movq (%rax), %r8
jmp 0x4d833
leaq 0x72dd(%rip), %r8       # 0x54b10
leaq 0x6d41(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0xd, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d874
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d888
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movss 0x6c68(%rip), %xmm1     # 0x544f8
callq 0x4ee58
movaps %xmm0, %xmm1
leaq 0x6d00(%rip), %rsi      # 0x5459f
leaq 0x6cea(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6c49(%rip), %xmm0     # 0x544fc
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4d91f
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d8d7
movq (%rax), %r8
jmp 0x4d8de
leaq 0x7232(%rip), %r8       # 0x54b10
leaq 0x6c96(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d91f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d933
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movss 0x6bc5(%rip), %xmm1     # 0x54500
callq 0x4ee58
movaps %xmm0, %xmm1
leaq 0x6c5f(%rip), %rsi      # 0x545a9
leaq 0x6c3f(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6ba6(%rip), %xmm0     # 0x54504
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4d9ca
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d982
movq (%rax), %r8
jmp 0x4d989
leaq 0x7187(%rip), %r8       # 0x54b10
leaq 0x6beb(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x13, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d9ca
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d9de
leaq 0x18(%rsp), %rdi
callq 0x39b7c
addq $0x20, %rsp
popq %rbx
retq
jmp 0x4d9ee
jmp 0x4d9ff
jmp 0x4d9ee
jmp 0x4da1b
jmp 0x4d9ff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xabd6
jmp 0x4da02
jmp 0x4da1b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4da11
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x4da1e
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4da32
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movq %rbx, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/El-Duder1no[P]geometry/test/main.cpp
// Function: areaTest_correctInput_Test::TestBody()
TEST(areaTest, correctInput)
{
    Circle one;

    one.r = 8.65124;
    EXPECT_FLOAT_EQ(235.12228, Area(one));

    one.r = 93.59;
    EXPECT_FLOAT_EQ(27516.6752, Area(one));

    one.r = 14.55;
    EXPECT_FLOAT_EQ(665.0634, Area(one));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss 0x6ac1(%rip), %xmm1     # 0x54508
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6b65(%rip), %rsi      # 0x545bb
leaq 0x6b68(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x6aa2(%rip), %xmm0     # 0x5450c
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4dad6
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4da8e
movq (%rax), %r8
jmp 0x4da95
leaq 0x707b(%rip), %r8       # 0x54b10
leaq 0x6adf(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x1b, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4dad6
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4daea
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movss 0x6a1e(%rip), %xmm1     # 0x54510
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6ace(%rip), %rsi      # 0x545cf
leaq 0x6abd(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x69ff(%rip), %xmm0     # 0x54514
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4db81
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4db39
movq (%rax), %r8
jmp 0x4db40
leaq 0x6fd0(%rip), %r8       # 0x54b10
leaq 0x6a34(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x1e, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4db81
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4db95
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movss 0x697b(%rip), %xmm1     # 0x54518
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6a2e(%rip), %rsi      # 0x545da
leaq 0x6a12(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x695c(%rip), %xmm0     # 0x5451c
movq %rbx, %rdi
callq 0x4e932
cmpb $0x0, (%rbx)
jne 0x4dc2c
movq %rsp, %rdi
callq 0xcaca
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4dbe4
movq (%rax), %r8
jmp 0x4dbeb
leaq 0x6f25(%rip), %r8       # 0x54b10
leaq 0x6989(%rip), %rdx      # 0x5457b
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x21, %ecx
callq 0xab68
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xac10
leaq 0x8(%rsp), %rdi
callq 0xabd6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4dc2c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4dc40
leaq 0x18(%rsp), %rdi
callq 0x39b7c
addq $0x20, %rsp
popq %rbx
retq
jmp 0x4dc50
jmp 0x4dc61
jmp 0x4dc50
jmp 0x4dc7d
jmp 0x4dc61
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xabd6
jmp 0x4dc64
jmp 0x4dc7d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4dc73
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x4dc80
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4dc94
leaq 0x18(%rsp), %rdi
callq 0x39b7c
movq %rbx, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6080(%rip), %xmm0     # 0x54530
movss 0x6068(%rip), %xmm1     # 0x54520
xorps %xmm2, %xmm2
movaps %xmm1, %xmm3
callq 0x4f488
leaq 0x20(%rsp), %rbx
movb %al, -0x8(%rbx)
movq $0x0, (%rbx)
testb %al, %al
jne 0x4e56c
leaq 0x8(%rsp), %rdi
callq 0xcaca
leaq 0x61ca(%rip), %rdx      # 0x546b5
leaq 0x612a(%rip), %rcx      # 0x5461c
leaq 0x6129(%rip), %r8       # 0x54622
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xeb93
movq 0x28(%rsp), %r8
leaq 0x6067(%rip), %rdx      # 0x5457b
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x49, %ecx
callq 0xab68
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xac10
leaq 0x10(%rsp), %rdi
callq 0xabd6
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e55c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e56c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e57e
movq %rbx, %rdi
callq 0x39b7c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xabd6
jmp 0x4e598
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e5b8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95f0
jmp 0x4e5b8
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e5c8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x4e5d6
movq %rax, %r14
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e5e8
movq %rbx, %rdi
callq 0x39b7c
movq %r14, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f42(%rip), %xmm0     # 0x54540
movaps 0x5f4b(%rip), %xmm2     # 0x54550
movss 0x5f13(%rip), %xmm1     # 0x54520
movaps %xmm1, %xmm3
callq 0x4f488
xorb $0x1, %al
leaq 0x20(%rsp), %rbx
movb %al, -0x8(%rbx)
movq $0x0, (%rbx)
jne 0x4e6be
leaq 0x8(%rsp), %rdi
callq 0xcaca
leaq 0x6078(%rip), %rdx      # 0x546b5
leaq 0x5fde(%rip), %rcx      # 0x54622
leaq 0x5fd1(%rip), %r8       # 0x5461c
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xeb93
movq 0x28(%rsp), %r8
leaq 0x5f15(%rip), %rdx      # 0x5457b
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x58, %ecx
callq 0xab68
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xac10
leaq 0x10(%rsp), %rdi
callq 0xabd6
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e6ae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e6be
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e6d0
movq %rbx, %rdi
callq 0x39b7c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xabd6
jmp 0x4e6ea
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e70a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x95f0
jmp 0x4e70a
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e71a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x4e728
movq %rax, %r14
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x4e73a
movq %rbx, %rdi
callq 0x39b7c
movq %r14, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/El-Duder1no[P]geometry/thirdparty/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetSetUpCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
                                                        int line_num) {
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);

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

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x20552
testb %al, %al
jne 0x4e819
leaq 0x5f9b(%rip), %rdx      # 0x54704
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x204, %ecx            # imm = 0x204
callq 0x28580
movq 0x27864(%rip), %rdi     # 0x75fe8
leaq 0x5fb7(%rip), %rsi      # 0x54742
movl $0x32, %edx
callq 0x9760
movq 0x2784c(%rip), %r15     # 0x75fe8
leaq 0x5fd2(%rip), %rsi      # 0x54775
movl $0x6a, %edx
movq %r15, %rdi
callq 0x9760
testq %r14, %r14
je 0x4e7d1
movq %r14, %rdi
callq 0x9240
movq 0x27824(%rip), %rdi     # 0x75fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x9760
jmp 0x4e7e9
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9c00
movq 0x277f8(%rip), %rdi     # 0x75fe8
leaq 0x5fe9(%rip), %rsi      # 0x547e0
movl $0x1, %edx
callq 0x9760
movq 0x277e0(%rip), %rdi     # 0x75fe8
movl %ebx, %esi
callq 0x9c30
leaq 0xc(%rsp), %rdi
callq 0x286ac
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x286ac
movq %rbx, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/El-Duder1no[P]geometry/thirdparty/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
                                                           int line_num) {
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);

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

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x20552
testb %al, %al
jne 0x4e911
leaq 0x5ea3(%rip), %rdx      # 0x54704
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x213, %ecx            # imm = 0x213
callq 0x28580
movq 0x2776c(%rip), %rdi     # 0x75fe8
leaq 0x5ebf(%rip), %rsi      # 0x54742
movl $0x32, %edx
callq 0x9760
movq 0x27754(%rip), %r15     # 0x75fe8
leaq 0x5f47(%rip), %rsi      # 0x547e2
movl $0x6f, %edx
movq %r15, %rdi
callq 0x9760
testq %r14, %r14
je 0x4e8c9
movq %r14, %rdi
callq 0x9240
movq 0x2772c(%rip), %rdi     # 0x75fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x9760
jmp 0x4e8e1
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9c00
movq 0x27700(%rip), %rdi     # 0x75fe8
leaq 0x5ef1(%rip), %rsi      # 0x547e0
movl $0x1, %edx
callq 0x9760
movq 0x276e8(%rip), %rdi     # 0x75fe8
movl %ebx, %esi
callq 0x9c30
leaq 0xc(%rsp), %rdi
callq 0x286ac
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x286ac
movq %rbx, %rdi
callq 0x9c60
// File: /workspace/github_cpp_makefile_star2_O1/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
cvtss2sd %xmm2, %xmm4
mulsd %xmm4, %xmm4
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm4, %xmm0
xorps %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x4f4b5
sqrtsd %xmm0, %xmm0
jmp 0x4f4d8
pushq %rax
movss %xmm3, 0x4(%rsp)
movss %xmm1, (%rsp)
callq 0x9480
xorps %xmm2, %xmm2
movss (%rsp), %xmm1
movss 0x4(%rsp), %xmm3
addq $0x8, %rsp
ucomisd %xmm2, %xmm0
movb $0x1, %al
jne 0x4f4ea
jp 0x4f4ea
ucomiss %xmm3, %xmm1
jne 0x4f4ea
jp 0x4f4ea
retq
movaps %xmm1, %xmm2
addss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x4f4fe
xorl %eax, %eax
retq
cvtss2sd %xmm1, %xmm1
movapd %xmm0, %xmm4
addsd %xmm1, %xmm4
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
ucomisd %xmm2, %xmm4
jb 0x4f4fb
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x4f4e9
jmp 0x4f4fb
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
movq %r14, 0xe8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x354(%rdi)
movups %xmm0, 0x364(%rdi)
movq %r14, 0x374(%rdi)
movups %xmm0, 0x98(%rdi)
movq %r14, 0xa8(%rdi)
movups %xmm0, 0x33c(%rdi)
movl $0x13e0, %edx           # imm = 0x13E0
xorl %esi, %esi
callq 0x7220
movdqa 0x35212(%rip), %xmm0    # 0x3d2c0
movdqu %xmm0, (%rbx)
leaq 0x355af(%rip), %rax     # 0x3d668
movq %rax, 0x10(%rbx)
leaq 0x355ae(%rip), %rax     # 0x3d672
movq %rax, 0x18(%rbx)
leaq 0x56f69(%rip), %rax     # 0x5f038
movq %rax, 0x88(%rbx)
movl $0x3f800000, 0x90(%rbx) # imm = 0x3F800000
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x98(%rbx)
movabsq $-0x407fffff40800000, %rax # imm = 0xBF800000BF800000
movq %rax, 0xe8(%rbx)
movq %rax, 0x33c(%rbx)
movabsq $0x40c000003e99999a, %rax # imm = 0x40C000003E99999A
movq %rax, 0x20(%rbx)
movl $0x40c00000, 0x28(%rbx) # imm = 0x40C00000
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x2c(%rbx)
movdqu %xmm0, 0x3c(%rbx)
movdqu %xmm0, 0x4c(%rbx)
movdqu %xmm0, 0x5c(%rbx)
movdqu %xmm0, 0x68(%rbx)
movabsq $0x3d4ccccd3e800000, %rax # imm = 0x3D4CCCCD3E800000
movq %rax, 0x78(%rbx)
movq %r14, 0x80(%rbx)
movq %r14, 0xb0(%rbx)
movq 0x4ce82(%rip), %rax     # 0x54fe0
movq %rax, 0xc8(%rbx)
movq 0x4ce3c(%rip), %rax     # 0x54fa8
movq %rax, 0xd0(%rbx)
leaq 0x28(%rip), %rax        # 0x81a2
movq %rax, 0xb8(%rbx)
leaq 0x2e(%rip), %rax        # 0x81b6
movq %rax, 0xc0(%rbx)
leaq 0xa9(%rip), %rax        # 0x823f
movq %rax, 0xd8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d2c6(%rip), %r15     # 0x55490
movq 0x2be0(%r15), %rdi
testq %rdi, %rdi
je 0x81ef
decl 0x334(%r15)
callq *0xd8(%r15)
movq $0x0, 0x2be0(%r15)
movq %rbx, %rdi
callq 0x72f0
movq %rax, %r14
leaq 0x1(%rax), %rdi
movq 0x4d28b(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiIO::AddInputCharacter(unsigned short)
void ImGuiIO::AddInputCharacter(ImWchar c)
{
    const int n = ImStrlenW(InputCharacters);
    if (n + 1 < IM_ARRAYSIZE(InputCharacters))
    {
        InputCharacters[n] = c;
        InputCharacters[n+1] = '\0';
    }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movl $0x11, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x832a
movzwl (%r14), %ecx
testw %cx, %cx
je 0x8321
xorl %eax, %eax
cmpw $0x0, 0x300(%rbx)
movl $0x0, %edx
je 0x82f4
xorl %edx, %edx
cmpw $0x0, 0x302(%rbx,%rdx,2)
leaq 0x1(%rdx), %rdx
jne 0x82e5
cmpl $0xf, %edx
jg 0x830e
movslq %edx, %rdx
movw %cx, 0x300(%rbx,%rdx,2)
movw $0x0, 0x302(%rbx,%rdx,2)
cmpq $0xf, %rax
ja 0x8321
movzwl -0x3e(%rbp,%rax,2), %ecx
incq %rax
testw %cx, %cx
jne 0x82d4
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x40(%rbp)
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,2), %r15
addq $-0x2, %r15
leaq -0x2c(%rbp), %rbx
movq %rdi, -0x38(%rbp)
testq %r13, %r13
sete %al
cmpq %r13, %r12
setb %cl
cmpq %r15, %r14
jae 0x83a4
orb %cl, %al
je 0x83a4
cmpb $0x0, (%r12)
je 0x83a4
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x884d
movl -0x2c(%rbp), %ecx
leal -0x1(%rcx), %edx
cmpl $0xfffe, %edx           # imm = 0xFFFE
ja 0x839b
movw %cx, (%r14)
addq $0x2, %r14
movl %eax, %eax
addq %rax, %r12
testl %ecx, %ecx
jne 0x835b
movw $0x0, (%r14)
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x83b6
movq %r12, (%rax)
subq -0x38(%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_O1/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 0x72f0
leaq 0x1(%rax), %rdi
movq 0x4cef8(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x85ba
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7300
leaq 0x350bf(%rip), %rdi     # 0x3d680
leaq 0x350bd(%rip), %rsi     # 0x3d685
leaq 0x350c8(%rip), %rcx     # 0x3d697
movl $0x30b, %edx            # imm = 0x30B
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x8729
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rcx
movq %rdi, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movslq %esi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74e0
movb $0x0, -0x1(%rbx,%r14)
cmpl $-0x1, %eax
cmovel %r14d, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x568f9(%rip)     # 0x5f094
jne 0x87da
xorl %eax, %eax
leaq 0x568ea(%rip), %rcx     # 0x5f090
movl $0x8, %r8d
movl %eax, %r9d
movl %r9d, %r10d
shrl %r10d
andl $0x1, %r9d
negl %r9d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
xorl %r10d, %r9d
decl %r8d
jne 0x87af
movl %r9d, (%rcx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x87a6
notl %edx
testl %esi, %esi
jle 0x880a
movl %esi, %ecx
xorl %esi, %esi
leaq 0x568a5(%rip), %r8      # 0x5f090
movl %edx, %eax
shrl $0x8, %eax
movzbl %dl, %edx
movzbl (%rdi,%rsi), %r9d
xorl %edx, %r9d
xorl (%r8,%r9,4), %eax
incq %rsi
movl %eax, %edx
cmpl %esi, %ecx
jne 0x87ed
jmp 0x884a
pushq %rbp
movq %rsp, %rbp
addq $0x2, %rdi
leaq 0x56877(%rip), %rcx     # 0x5f090
movl %edx, %eax
movzbl -0x2(%rdi), %esi
testl %esi, %esi
je 0x8842
cmpl $0x23, %esi
jne 0x8834
cmpb $0x23, -0x1(%rdi)
jne 0x8834
cmpb $0x23, (%rdi)
cmovel %edx, %eax
movzbl %al, %r8d
shrl $0x8, %eax
xorl %esi, %r8d
xorl (%rcx,%r8,4), %eax
incq %rdi
testl %esi, %esi
jne 0x881b
popq %rbp
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImTextStrToUtf8(char*, int, unsigned short const*, unsigned short const*)
int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
    char* buf_out = buf;
    const char* buf_end = buf + buf_size;
    while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            *buf_out++ = (char)c;
        else
            buf_out += ImTextCharToUtf8(buf_out, (int)(buf_end-buf_out-1), c);
    }
    *buf_out = 0;
    return (int)(buf_out - buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rsi
leaq (%rdi,%rsi), %r8
decq %r8
movq %rdi, %rax
cmpq %rdi, %r8
jbe 0x8bef
addq %rdi, %rsi
movq %rdi, %rax
testq %rcx, %rcx
sete %r9b
cmpq %rcx, %rdx
setb %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x8bef
movzwl (%rdx), %r9d
testl %r9d, %r9d
je 0x8bef
cmpw $0x7f, %r9w
ja 0x8b1c
movb %r9b, (%rax)
incq %rax
jmp 0x8be2
movl %eax, %r10d
notl %r10d
addl %esi, %r10d
cmpl $0x7ff, %r9d            # imm = 0x7FF
ja 0x8b53
cmpl $0x2, %r10d
jl 0x8ba1
movl %r9d, %r10d
shrl $0x6, %r10d
orb $-0x40, %r10b
movb %r10b, (%rax)
movl $0x2, %r10d
movl $0x1, %r11d
jmp 0x8bd3
movl %r9d, %r11d
andl $0xfc00, %r11d          # imm = 0xFC00
cmpl $0xdc00, %r11d          # imm = 0xDC00
je 0x8ba1
cmpl $0xd800, %r11d          # imm = 0xD800
jne 0x8b9b
cmpl $0x4, %r10d
jl 0x8ba1
movw $0x8df0, (%rax)         # imm = 0x8DF0
movl %r9d, %r10d
shrl $0x6, %r10d
andb $0x2f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x2(%rax)
movl $0x4, %r10d
movl $0x3, %r11d
jmp 0x8bd3
cmpl $0x3, %r10d
jge 0x8ba6
xorl %r10d, %r10d
jmp 0x8bdf
movl %r9d, %r10d
shrl $0xc, %r10d
orb $-0x20, %r10b
movb %r10b, (%rax)
movl %r9d, %r10d
shrl $0x6, %r10d
andb $0x3f, %r10b
orb $-0x80, %r10b
movb %r10b, 0x1(%rax)
movl $0x3, %r10d
movl $0x2, %r11d
andb $0x3f, %r9b
orb $-0x80, %r9b
movb %r9b, (%rax,%r11)
addq %r10, %rax
addq $0x2, %rdx
cmpq %r8, %rax
jb 0x8ae2
movb $0x0, (%rax)
subl %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3469d(%rip), %xmm0    # 0x3d380
movaps %xmm0, %xmm5
minss %xmm3, %xmm5
movss 0x34696(%rip), %xmm1    # 0x3d388
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_O1/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 0x34612(%rip), %xmm4    # 0x3d38c
andps %xmm3, %xmm4
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
maxss %xmm1, %xmm2
movss 0x34600(%rip), %xmm1    # 0x3d390
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 0x345c7(%rip), %xmm0    # 0x3d394
mulss %xmm4, %xmm0
movss 0x345bf(%rip), %xmm3    # 0x3d398
addss %xmm3, %xmm0
divss %xmm0, %xmm1
addss %xmm5, %xmm1
andps 0x344e4(%rip), %xmm1    # 0x3d2d0
movss %xmm1, (%rdi)
addss %xmm2, %xmm3
divss %xmm3, %xmm4
movss %xmm4, (%rsi)
movss %xmm2, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e3b
jp 0x8e3b
movss %xmm2, (%rbx)
movss %xmm2, (%r14)
movss %xmm2, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movss 0x3453d(%rip), %xmm1    # 0x3d380
movss %xmm2, -0x20(%rbp)
movss %xmm3, -0x1c(%rbp)
callq 0x78f0
movss -0x1c(%rbp), %xmm6
movss 0x34521(%rip), %xmm5    # 0x3d380
movss -0x20(%rbp), %xmm4
divss 0x34530(%rip), %xmm0    # 0x3d39c
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 0x8f11
movaps %xmm5, %xmm3
subss %xmm0, %xmm3
mulss %xmm3, %xmm6
subss %xmm6, %xmm5
mulss %xmm4, %xmm5
leaq 0x345b9(%rip), %rcx     # 0x3d470
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss %xmm4, (%r15)
movss %xmm5, (%r14)
jmp 0x8f08
movss %xmm5, (%r15)
movss %xmm1, (%r14)
jmp 0x8ef5
movss %xmm1, (%r15)
movss %xmm4, (%r14)
movss %xmm5, (%rbx)
jmp 0x8e30
movss %xmm1, (%r15)
movss %xmm2, (%r14)
movss %xmm4, (%rbx)
jmp 0x8e30
movss %xmm2, (%r15)
movss %xmm4, (%r14)
movss %xmm1, (%rbx)
jmp 0x8e30
movss %xmm4, (%r15)
movss %xmm1, (%r14)
movss %xmm2, (%rbx)
jmp 0x8e30
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9046
testq %rsi, %rsi
je 0x9046
movl %ecx, %r14d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8f55
movl $0x0, (%rbx)
callq 0x78d0
testq %rax, %rax
je 0x8f7d
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x78c0
testl %eax, %eax
je 0x8f92
movq %r15, %rdi
callq 0x7340
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 0x71f0
cmpq $-0x1, %rax
je 0x8f75
movq %rax, %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x78c0
testl %eax, %eax
jne 0x8f75
leal (%r14,%r13), %eax
movslq %eax, %rdi
movq 0x4c4cf(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
testq %rax, %rax
je 0x8f75
movq %rax, %r12
movslq %r13d, %rdx
movq %rdx, -0x30(%rbp)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x7410
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9023
testl %r14d, %r14d
jle 0x900a
movq %r12, %rdi
addq %rcx, %rdi
movl %r14d, %edx
xorl %esi, %esi
callq 0x7220
movq %r15, %rdi
callq 0x7340
testq %rbx, %rbx
je 0x8f80
movl %r13d, (%rbx)
jmp 0x8f80
movq %r15, %rdi
callq 0x7340
movq 0x4c45e(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq %r12, %rdi
callq *0xd8(%rax)
jmp 0x8f7d
leaq 0x34667(%rip), %rdi     # 0x3d6b4
leaq 0x34631(%rip), %rsi     # 0x3d685
leaq 0x34674(%rip), %rcx     # 0x3d6cf
movl $0x468, %edx            # imm = 0x468
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetInt(unsigned int, int) const
int ImGuiStorage::GetInt(ImU32 key, int default_val) const
{
    ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return default_val;
    return it->val_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movq 0x8(%rdi), %rdx
movslq (%rdi), %rdi
movq %rdx, %rcx
testq %rdi, %rdi
jle 0x9106
movq %rdx, %rcx
movl %edi, %r9d
movl %r9d, %r8d
shrl %r8d
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rcx,%r10)
jae 0x90fe
notl %r8d
addl %r8d, %r9d
addq %r10, %rcx
addq $0x10, %rcx
movl %r9d, %r8d
movl %r8d, %r9d
testl %r8d, %r8d
jg 0x90db
shlq $0x4, %rdi
addq %rdi, %rdx
cmpq %rdx, %rcx
je 0x9119
cmpl %esi, (%rcx)
jne 0x9119
movl 0x8(%rcx), %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
jle 0x915d
movq %rcx, %rax
movl %edx, %r8d
movl %r8d, %edi
shrl %edi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x9156
notl %edi
addl %edi, %r8d
addq %r9, %rax
addq $0x10, %rax
movl %r8d, %edi
movl %edi, %r8d
testl %edi, %edi
jg 0x9135
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x9172
cmpl %esi, (%rax)
jne 0x9172
movss 0x8(%rax), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
jle 0x91b5
movq %rcx, %rax
movl %edx, %r8d
movl %r8d, %edi
shrl %edi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x91ae
notl %edi
addl %edi, %r8d
addq %r9, %rax
addq $0x10, %rax
movl %r8d, %edi
movl %edi, %r8d
testl %edi, %edi
jg 0x918d
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x91cb
cmpl %esi, (%rax)
jne 0x91cb
movq 0x8(%rax), %rax
jmp 0x91cd
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStorage::GetIntRef(unsigned int, int)
int* ImGuiStorage::GetIntRef(ImGuiID key, int default_val)
{
    ImVector<Pair>::iterator it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, Pair(key, default_val));
    return &it->val_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r8d
movl %esi, %r12d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movslq (%rdi), %rax
movq %rcx, %rbx
testq %rax, %rax
jle 0x9222
movq %rcx, %rbx
movl %eax, %esi
movl %esi, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %r12d, (%rbx,%rdi)
jae 0x921c
notl %edx
addl %edx, %esi
addq %rdi, %rbx
addq $0x10, %rbx
movl %esi, %edx
movl %edx, %esi
testl %edx, %edx
jg 0x91fe
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %rbx
je 0x923a
cmpl %r12d, (%rbx)
je 0x9314
cmpq %rbx, %rcx
ja 0x932a
cmpq %rbx, %rdx
jb 0x932a
subq %rcx, %rbx
movq %rbx, %r15
sarq $0x4, %r15
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x92da
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x4, %r13d
cmovnel %eax, %r13d
cmpl %r13d, %ecx
jge 0x92da
movl %r8d, -0x2c(%rbp)
movslq %r13d, %rdi
shlq $0x4, %rdi
movq 0x4c20c(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x4, %rdx
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x92bd
movq 0x4c1d9(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4c1cc(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
movl %r13d, 0x4(%r14)
movl -0x2c(%rbp), %r8d
movslq (%r14), %rdx
subq %r15, %rdx
jle 0x9300
movq 0x8(%r14), %rsi
leaq (%rsi,%rbx), %rdi
addq $0x10, %rdi
addq %rbx, %rsi
shlq $0x4, %rdx
movl %r8d, %r15d
callq 0x7130
movl %r15d, %r8d
movq 0x8(%r14), %rax
movl %r12d, (%rax,%rbx)
movl %r8d, 0x8(%rax,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35d47(%rip), %rdi     # 0x3f078
leaq 0x3575b(%rip), %rsi     # 0x3ea93
leaq 0x35d56(%rip), %rcx     # 0x3f095
movl $0x33b, %edx            # imm = 0x33B
callq 0x7140
nop