LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/CMRRandomGenerator.h
// Function: Utils::CMRRandomGenerator::mm_mul(long (*) [3], long (*) [3], long (*) [3], long)
static void mm_mul(int64_t a[][3], int64_t b[][3], int64_t c[][3], int64_t m)
			{
				int64_t d [3][3];

				for (int i = 0; i <= 2; i++) {
					for (int j = 0; j <= 2; j++) {
						d[i][j] = 0;
						for (int k = 0; k <= 2; k++) {
							d[i][j] = (a[i][k] * b[k][j] + d[i][j]) % m;
						}
					}
				}
				m_copy(d, c);
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r8
xorl %r9d, %r9d
leaq (%r9,%r9,2), %rax
leaq (%rsp,%rax,8), %r10
addq $-0x48, %r10
movq %rsi, %r11
xorl %ebx, %ebx
leaq (%r10,%rbx,8), %r14
movq $0x0, (%r14)
movq %r11, %r15
xorl %r12d, %r12d
xorl %edx, %edx
movq (%r15), %rax
imulq (%rdi,%r12,8), %rax
addq %rdx, %rax
cqto
idivq %rcx
incq %r12
addq $0x18, %r15
cmpq $0x3, %r12
jne 0x527a3
movq %rdx, (%r14)
incq %rbx
addq $0x8, %r11
cmpq $0x3, %rbx
jne 0x52790
incq %r9
addq $0x18, %rdi
cmpq $0x3, %r9
jne 0x5277f
xorl %eax, %eax
movq -0x38(%rsp,%rax), %rcx
movq %rcx, 0x10(%r8,%rax)
movups -0x48(%rsp,%rax), %xmm0
movups %xmm0, (%r8,%rax)
addq $0x18, %rax
cmpq $0x48, %rax
jne 0x527df
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Helper_Functions.cpp
// Function: Utils::Combination_count(double, double)
double Combination_count(double n, double k)
	{
		if (k > n) {
			return 0;
		}
		
		if (k * 2 > n) {
			k = n - k;
		}

		if (k == 0) {
			return 1;
		}

		double result = n;
		for (int i = 2; i <= k; ++i) {
			result *= (n - i + 1);
			result /= i;
		}

		return result;
	}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm1
ja 0x528a1
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
movapd %xmm0, %xmm4
subsd %xmm1, %xmm4
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm4
andnpd %xmm1, %xmm3
orpd %xmm4, %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
jne 0x52851
jp 0x52851
movsd 0x53c1(%rip), %xmm2     # 0x57c10
jmp 0x528a1
ucomisd 0x80a7(%rip), %xmm3     # 0x5a900
jae 0x52861
movapd %xmm0, %xmm2
jmp 0x528a1
movsd 0x8097(%rip), %xmm1     # 0x5a900
movl $0x3, %eax
movsd 0x539a(%rip), %xmm4     # 0x57c10
movapd %xmm0, %xmm5
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
addsd %xmm4, %xmm2
mulsd %xmm5, %xmm2
divsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
incl %eax
ucomisd %xmm1, %xmm3
movapd %xmm2, %xmm5
jae 0x5287a
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::Reset()
void Logical_Address_Partitioning_Unit::Reset()
	{
		initialized = false;
		pdas_per_flow.clear();
		start_lhas_per_flow.clear();
		end_lhas_per_flow.clear();
		stream_channel_ids.clear();
		stream_chip_ids.clear();
		stream_die_ids.clear();
		stream_plane_ids.clear();

		for (flash_channel_ID_type channel_id = 0; channel_id < channel_count; channel_id++) {
			for (flash_chip_ID_type chip_id = 0; chip_id < chip_no_per_channel; chip_id++) {
				for (flash_die_ID_type die_id = 0; die_id < die_no_per_chip; die_id++) {
					delete[] resource_list[channel_id][chip_id][die_id];
				}
				delete[] resource_list[channel_id][chip_id];
			}
			delete[] resource_list[channel_id];
		}

		delete[] resource_list;
	}

// Assembly:
movb $0x0, 0x2103d(%rip)     # 0x73cc4
movq 0x2103a(%rip), %rax     # 0x73cc8
cmpq %rax, 0x2103b(%rip)     # 0x73cd0
je 0x52c9e
movq %rax, 0x21032(%rip)     # 0x73cd0
movq 0x2103b(%rip), %rax     # 0x73ce0
cmpq %rax, 0x2103c(%rip)     # 0x73ce8
je 0x52cb5
movq %rax, 0x21033(%rip)     # 0x73ce8
movq 0x2103c(%rip), %rax     # 0x73cf8
cmpq %rax, 0x2103d(%rip)     # 0x73d00
je 0x52ccc
movq %rax, 0x21034(%rip)     # 0x73d00
pushq %r15
pushq %r14
pushq %rbx
leaq 0x20f88(%rip), %rdi     # 0x73c60
callq 0x53b16
leaq 0x20f94(%rip), %rdi     # 0x73c78
callq 0x53b16
leaq 0x20fa0(%rip), %rdi     # 0x73c90
callq 0x53b16
leaq 0x20fac(%rip), %rdi     # 0x73ca8
callq 0x53b16
cmpl $0x0, 0x21008(%rip)     # 0x73d10
je 0x52da1
xorl %ebx, %ebx
cmpl $0x0, 0x20ffd(%rip)     # 0x73d14
je 0x52d7a
xorl %r14d, %r14d
cmpl $0x0, 0x20ff5(%rip)     # 0x73d18
je 0x52d53
xorl %r15d, %r15d
movq 0x20f29(%rip), %rax     # 0x73c58
movq (%rax,%rbx,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x52d45
callq 0x7480
incq %r15
movl 0x20fca(%rip), %eax     # 0x73d18
cmpq %rax, %r15
jb 0x52d28
movq 0x20efe(%rip), %rax     # 0x73c58
movq (%rax,%rbx,8), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x52d6c
callq 0x7480
incq %r14
movl 0x20f9f(%rip), %eax     # 0x73d14
cmpq %rax, %r14
jb 0x52d1c
movq 0x20ed7(%rip), %rax     # 0x73c58
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x52d8f
callq 0x7480
incq %rbx
movl 0x20f78(%rip), %eax     # 0x73d10
cmpq %rax, %rbx
jb 0x52d10
movq 0x20eb0(%rip), %rdi     # 0x73c58
testq %rdi, %rdi
popq %rbx
popq %r14
popq %r15
jne 0x7480
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::Start_lha_available_to_flow(unsigned short)
LHA_type Logical_Address_Partitioning_Unit::Start_lha_available_to_flow(stream_id_type stream_id)
	{
		if (initialized) {
			switch (hostinterface_type) {
				case HostInterface_Types::SATA:
					return start_lhas_per_flow[stream_id];
					break;
				case HostInterface_Types::NVME:
					return start_lhas_per_flow[stream_id];
					break;
				default:
					break;
			}
		}

		PRINT_ERROR("The address partitioning unit is not initialized!")
	}

// Assembly:
cmpb $0x1, 0x203f9(%rip)     # 0x73cc4
jne 0x538e5
cmpl $0x2, 0x203ec(%rip)     # 0x73cc0
jae 0x538e5
movq 0x20403(%rip), %rax     # 0x73ce0
movzwl %di, %ecx
movq (%rax,%rcx,8), %rax
retq
pushq %rbx
movq 0x1b703(%rip), %rbx     # 0x6eff0
leaq 0x2cb4(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x700d(%rip), %rsi      # 0x5a910
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1b6b6(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::End_lha_available_to_flow(unsigned short)
LHA_type Logical_Address_Partitioning_Unit::End_lha_available_to_flow(stream_id_type stream_id)
	{
		if (initialized) {
			switch (hostinterface_type) {
				case HostInterface_Types::SATA:
					return end_lhas_per_flow[stream_id];
					break;
				case HostInterface_Types::NVME:
					return end_lhas_per_flow[stream_id];
					break;
				default:
					break;
			}
		}
		PRINT_ERROR("The address partitioning unit is not initialized!")
	}

// Assembly:
cmpb $0x1, 0x20393(%rip)     # 0x73cc4
jne 0x5394b
cmpl $0x2, 0x20386(%rip)     # 0x73cc0
jae 0x5394b
movq 0x203b5(%rip), %rax     # 0x73cf8
movzwl %di, %ecx
movq (%rax,%rcx,8), %rax
retq
pushq %rbx
movq 0x1b69d(%rip), %rbx     # 0x6eff0
leaq 0x2c4e(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6fa7(%rip), %rsi      # 0x5a910
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1b650(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::LHA_count_allocate_to_flow_from_host_view(unsigned short)
LHA_type Logical_Address_Partitioning_Unit::LHA_count_allocate_to_flow_from_host_view(stream_id_type stream_id)
	{
		if (initialized) {
			switch (hostinterface_type) {
				case HostInterface_Types::SATA:
					return (end_lhas_per_flow[stream_id] - start_lhas_per_flow[stream_id] + 1);
					break;
				case HostInterface_Types::NVME:
					return (end_lhas_per_flow[stream_id] - start_lhas_per_flow[stream_id] + 1);
					break;
				default:
					break;
			}
		}
		PRINT_ERROR("The address partitioning unit is not initialized!")
	}

// Assembly:
cmpb $0x1, 0x2032d(%rip)     # 0x73cc4
jne 0x539c2
cmpl $0x2, 0x20320(%rip)     # 0x73cc0
jae 0x539c2
movq 0x2034f(%rip), %rax     # 0x73cf8
movzwl %di, %ecx
shll $0x3, %ecx
movq (%rax,%rcx), %rax
movq 0x20326(%rip), %rdx     # 0x73ce0
subq (%rdx,%rcx), %rax
incq %rax
retq
pushq %rbx
movq 0x1b626(%rip), %rbx     # 0x6eff0
leaq 0x2bd7(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6f30(%rip), %rsi      # 0x5a910
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1b5d9(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::LHA_count_allocate_to_flow_from_device_view(unsigned short)
LHA_type Logical_Address_Partitioning_Unit::LHA_count_allocate_to_flow_from_device_view(stream_id_type stream_id)
	{
		if (initialized) {
			switch (hostinterface_type) {
				case HostInterface_Types::SATA://It is not possible to differentiate between streams inside the device when a SATA host interface is used, so all lha space is available to all streams
					return total_lha_no;
					break;
				case HostInterface_Types::NVME:
					return (end_lhas_per_flow[stream_id] - start_lhas_per_flow[stream_id] + 1);
					break;
				default:
					break;
			}
		}
		PRINT_ERROR("The address partitioning unit is not initialized!")
	}

// Assembly:
cmpb $0x1, 0x202b7(%rip)     # 0x73cc4
jne 0x53a46
movl 0x202ab(%rip), %eax     # 0x73cc0
cmpl $0x1, %eax
je 0x53a26
testl %eax, %eax
jne 0x53a46
movq 0x20303(%rip), %rax     # 0x73d28
retq
movq 0x202cb(%rip), %rax     # 0x73cf8
movzwl %di, %ecx
shll $0x3, %ecx
movq (%rax,%rcx), %rax
movq 0x202a2(%rip), %rdx     # 0x73ce0
subq (%rdx,%rcx), %rax
incq %rax
retq
pushq %rbx
movq 0x1b5a2(%rip), %rbx     # 0x6eff0
leaq 0x2b53(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6eac(%rip), %rsi      # 0x5a910
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1b555(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/Logical_Address_Partitioning_Unit.cpp
// Function: Utils::Logical_Address_Partitioning_Unit::PDA_count_allocate_to_flow(unsigned short)
PDA_type Logical_Address_Partitioning_Unit::PDA_count_allocate_to_flow(stream_id_type stream_id)
	{
		if (initialized) {
			switch (hostinterface_type) {
				case HostInterface_Types::SATA://It is not possible to differentiate between streams inside the device when a SATA host interface is used, so all lha space is available to all streams
					return total_pda_no;
				case HostInterface_Types::NVME:
					return pdas_per_flow[stream_id];
					break;
				default:
					break;
			}
		}
		PRINT_ERROR("The address partitioning unit is not initialized!")
	}

// Assembly:
cmpb $0x1, 0x20233(%rip)     # 0x73cc4
jne 0x53abc
movl 0x20227(%rip), %eax     # 0x73cc0
testl %eax, %eax
je 0x53ab1
cmpl $0x1, %eax
jne 0x53abc
movzwl %di, %eax
shll $0x3, %eax
addq 0x20219(%rip), %rax     # 0x73cc8
jmp 0x53ab8
leaq 0x20268(%rip), %rax     # 0x73d20
movq (%rax), %rax
retq
pushq %rbx
movq 0x1b52c(%rip), %rbx     # 0x6eff0
leaq 0x2add(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6e36(%rip), %rsi      # 0x5a910
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1b4df(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Erlang(double, double)
double RandomGenerator::Erlang(double x, double s)
	{
		int64_t i, k;
		double z;
		z = x / s;
		k = (uint64_t)(z * z);
		z = 1.0;
		for (i = 0; i < k; i++) {
			z *= FloatRandom();
		}
		return -(x / (double) k) * log(z);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, (%rsp)
divsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1300(%rip), %xmm0     # 0x55050
cvttsd2si %xmm0, %r14
andq %rcx, %r14
orq %rax, %r14
jle 0x53d8a
movq %rdi, %rbx
movsd 0x3ea8(%rip), %xmm1     # 0x57c10
movq %r14, %r15
movsd %xmm1, 0x18(%rsp)
movq (%rbx), %rdi
callq 0x52680
movsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
decq %r15
jne 0x53d6b
jmp 0x53d92
movsd 0x3e7e(%rip), %xmm1     # 0x57c10
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movapd (%rsp), %xmm2
xorpd 0x54c9(%rip), %xmm2     # 0x59270
divsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm1, %xmm0
callq 0x7300
mulsd (%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::HyperExponential(double, double)
double RandomGenerator::HyperExponential(double x, double s)
	{
		if (s < x) {
			throw std::logic_error("RandomGenerator::HyperExponential: Mean must be greater than standard deviation.");
		}

		double cv, z, p;
		cv = s / x;
		z = cv * cv;
		p = 0.5 * (1.0 - sqrt((z - 1.0) / (z + 1.0)));
		z = (FloatRandom() > p) ? (x / (1.0 - p)) : (x / p);
		return -0.5 * z * log(FloatRandom());
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
ucomisd %xmm1, %xmm0
ja 0x53e93
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x6b56(%rip), %xmm0     # 0x5a948
addsd %xmm1, %xmm0
addsd 0x3e12(%rip), %xmm1     # 0x57c10
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x53e12
sqrtsd %xmm0, %xmm0
jmp 0x53e17
callq 0x72f0
movsd 0x3df1(%rip), %xmm1     # 0x57c10
subsd %xmm0, %xmm1
mulsd 0x5465(%rip), %xmm1     # 0x59290
movapd %xmm1, 0x10(%rsp)
movq (%rbx), %rdi
callq 0x52680
movsd 0x3dcf(%rip), %xmm2     # 0x57c10
movapd 0x10(%rsp), %xmm3
subsd %xmm3, %xmm2
movapd %xmm3, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
mulsd 0x6ade(%rip), %xmm0     # 0x5a950
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
callq 0x52680
callq 0x7300
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x71d0
movq %rax, %rbx
leaq 0x6ac9(%rip), %rsi      # 0x5a970
movq %rax, %rdi
callq 0x7500
movq 0x1b10a(%rip), %rsi     # 0x6efc0
movq 0x1b0cb(%rip), %rdx     # 0x6ef88
movq %rbx, %rdi
callq 0x75e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Normal(double, double)
double RandomGenerator::Normal(double x, double s)
	{
		double v1, v2, w, z1;
		if (Normal_z2 != 0.0) {
			/* use value from previous call */
			z1 = Normal_z2;
			Normal_z2 = 0.0;
		} else {
			do {
				v1 = 2.0 * FloatRandom() - 1.0;
				v2 = 2.0 * FloatRandom() - 1.0;
				w = v1 * v1 + v2 * v2;
			} while (w >= 1.0);

			w = sqrt((-2.0*log(w)) / w);
			z1 = v1 * w;
			Normal_z2 = v2 * w;
		}

		return x + z1 * s;
	}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movapd %xmm1, %xmm2
movapd %xmm0, %xmm3
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x53ef9
jnp 0x53f03
movsd 0x10(%rbx), %xmm0
jmp 0x53fad
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
movq (%rbx), %rdi
callq 0x52680
movapd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
callq 0x52680
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd %xmm1, %xmm1
addpd 0x6a26(%rip), %xmm1     # 0x5a960
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
ucomisd 0x3cb6(%rip), %xmm0     # 0x57c10
jae 0x53f0e
movapd %xmm1, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
callq 0x7300
mulsd 0x69e3(%rip), %xmm0     # 0x5a958
divsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x53f8b
sqrtsd %xmm0, %xmm0
jmp 0x53f90
callq 0x72f0
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x10(%rsp), %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm0
movhpd %xmm0, 0x10(%rbx)
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Geometric0(double)
int64_t RandomGenerator::Geometric0(double x)
	{
		double p = 1 / x;
		int64_t i = 0;
		while (FloatRandom() < p) {
			++i;
		}

		return i;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x3c31(%rip), %xmm1     # 0x57c10
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq $-0x1, %r14
movq (%rbx), %rdi
callq 0x52680
incq %r14
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x53fef
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Hyper_geometric(double, double)
double RandomGenerator::Hyper_geometric(double x, double s)
	{
		double sqrtz = s / x;
		double z = sqrtz * sqrtz;
		double p = 0.5 * (1 - sqrt((z - 1) / (z + 1)));
		double d = (FloatRandom() > p) ? (1 - p) : p;

		return -x * log(FloatRandom()) / (2 * d);
	}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd %xmm0, 0x10(%rsp)
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x68de(%rip), %xmm0     # 0x5a948
addsd %xmm1, %xmm0
addsd 0x3b9a(%rip), %xmm1     # 0x57c10
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5408a
sqrtsd %xmm0, %xmm0
jmp 0x5408f
callq 0x72f0
movsd 0x3b79(%rip), %xmm1     # 0x57c10
subsd %xmm0, %xmm1
mulsd 0x51ed(%rip), %xmm1     # 0x59290
movapd %xmm1, (%rsp)
movq (%rbx), %rdi
callq 0x52680
movsd 0x3b58(%rip), %xmm2     # 0x57c10
movapd (%rsp), %xmm3
subsd %xmm3, %xmm2
movapd %xmm3, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x5187(%rip), %xmm0     # 0x59270
movapd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
callq 0x52680
callq 0x7300
mulsd 0x10(%rsp), %xmm0
movapd (%rsp), %xmm1
addsd %xmm1, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Binomial(long, double)
int64_t RandomGenerator::Binomial(int64_t n, double u)
	{
		int64_t k = 0;
		for (long i = 0; i < n; i++) {
			if (FloatRandom() < u) {
				++k;
			}
		}

		return k;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
jle 0x54153
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movsd %xmm0, 0x8(%rsp)
movq (%r15), %rdi
callq 0x52680
xorl %eax, %eax
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addq %rax, %rbx
decq %r14
jne 0x54132
jmp 0x54155
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Poisson(double)
int64_t RandomGenerator::Poisson(double x)
	{
		double b = exp(-x);
		int64_t k = 0;
		double p = 1;
		while (p >= b) {
			++k;
			p *= FloatRandom();
		}

		return k - 1;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd 0x50fc(%rip), %xmm0     # 0x59270
callq 0x7640
movq $-0x1, %r14
movsd 0x3a88(%rip), %xmm1     # 0x57c10
ucomisd %xmm0, %xmm1
jb 0x541bb
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movq (%rbx), %rdi
callq 0x52680
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
incq %r14
ucomisd %xmm0, %xmm1
jae 0x54194
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Triangular(double, double, double)
double RandomGenerator::Triangular(double min, double middle, double max)
	{
		double y = FloatRandom();
		if (y <= (middle - min) / (max - min)) {
			return min + sqrt(y*max*middle - y*max*min - y*min*middle + y*min*min);
		} else {
			return max - sqrt(max*max + y*max*middle - y*max*max - y*min*middle + y*max*min - max*min - max*middle + min*middle);
		}
	}

// Assembly:
subq $0x18, %rsp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq (%rdi), %rdi
callq 0x52680
movsd 0x10(%rsp), %xmm6
movsd (%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movapd %xmm6, %xmm1
subsd %xmm4, %xmm1
movapd %xmm5, %xmm2
subsd %xmm4, %xmm2
divsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm0, %xmm1
mulsd %xmm5, %xmm1
movapd %xmm1, %xmm2
jae 0x54345
mulsd %xmm6, %xmm2
movapd %xmm5, %xmm3
mulsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movapd %xmm1, %xmm2
mulsd %xmm5, %xmm2
subsd %xmm2, %xmm3
mulsd %xmm4, %xmm0
mulsd %xmm6, %xmm0
subsd %xmm0, %xmm3
mulsd %xmm4, %xmm1
addsd %xmm3, %xmm1
movapd %xmm5, %xmm0
mulsd %xmm4, %xmm0
subsd %xmm0, %xmm1
movapd %xmm5, %xmm0
mulsd %xmm6, %xmm0
subsd %xmm0, %xmm1
mulsd %xmm6, %xmm4
addsd %xmm1, %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm4
jb 0x54378
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
jmp 0x54386
mulsd %xmm4, %xmm2
mulsd %xmm6, %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm0
mulsd %xmm0, %xmm6
subsd %xmm6, %xmm1
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5438c
xorps %xmm5, %xmm5
sqrtsd %xmm0, %xmm5
jmp 0x5439b
movapd %xmm4, %xmm0
callq 0x72f0
movsd (%rsp), %xmm5
subsd %xmm0, %xmm5
jmp 0x5439f
callq 0x72f0
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm5
addsd %xmm4, %xmm5
movapd %xmm5, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool XmlWriter::Open(const std::string strFile) {

		outFile.open(strFile);
		if (outFile.is_open()) {
			outFile << "<?xml version=\"1.0\" encoding=\"us-ascii\"?>\n";
			indent = 0;
			openTags = 0;
			openElements = 0;

			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edx
callq 0x71b0
leaq 0x70(%rbx), %rdi
callq 0x70e0
movl %eax, %ebp
testb %al, %al
je 0x5442e
leaq 0x65b5(%rip), %rsi      # 0x5a9c1
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x7400
movq $0x0, 0x200(%rbx)
movl $0x0, 0x208(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_open_tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_open_tag(const std::string openTag) {
		if (outFile.is_open()) {
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			tempOpenTag.resize(openTags + 1);
			outFile << "<" << openTag << ">\n";
			tempOpenTag[openTags] = openTag;
			indent += 1;
			openTags += 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x54528
cmpl $0x0, 0x200(%rbx)
jle 0x5449e
xorl %ebp, %ebp
leaq 0x3556(%rip), %r15      # 0x579da
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7400
incl %ebp
cmpl 0x200(%rbx), %ebp
jl 0x54484
leaq 0x210(%rbx), %rdi
movslq 0x204(%rbx), %rsi
incq %rsi
callq 0x54d64
leaq 0x1101(%rip), %rsi      # 0x555bc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7400
leaq 0x6549(%rip), %rsi      # 0x5aa27
movl $0x2, %edx
movq %rax, %rdi
callq 0x7400
movslq 0x204(%rbx), %rdi
shlq $0x5, %rdi
addq 0x210(%rbx), %rdi
movq %r14, %rsi
callq 0x7220
movq 0x200(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1aac1(%rip), %rbx     # 0x6eff0
leaq 0x2072(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x64a7(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1aa74(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_close_tag()
void XmlWriter::Write_close_tag() {
		if (outFile.is_open()) {
			indent -= 1;
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			outFile << "</" << tempOpenTag[openTags - 1] << ">\n";
			tempOpenTag.resize(openTags - 1);
			openTags -= 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x548bb
movl 0x200(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x200(%rbx)
cmpl $0x2, %eax
jl 0x5484b
xorl %ebp, %ebp
leaq 0x31a9(%rip), %r14      # 0x579da
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7400
incl %ebp
cmpl 0x200(%rbx), %ebp
jl 0x54831
leaq 0x61d1(%rip), %rsi      # 0x5aa23
movl $0x2, %edx
movq %rbx, %rdi
callq 0x7400
leaq 0x210(%rbx), %r14
movslq 0x204(%rbx), %rax
movq 0x210(%rbx), %rcx
shlq $0x5, %rax
movq -0x20(%rcx,%rax), %rsi
movq -0x18(%rcx,%rax), %rdx
movq %rbx, %rdi
callq 0x7400
leaq 0x6196(%rip), %rsi      # 0x5aa27
movl $0x2, %edx
movq %rax, %rdi
callq 0x7400
movslq 0x204(%rbx), %rsi
decq %rsi
movq %r14, %rdi
callq 0x54d64
decl 0x204(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1a72e(%rip), %rbx     # 0x6eff0
leaq 0x1cdf(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6114(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a6e1(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_start_element_tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_start_element_tag(const std::string elementTag) {
		if (outFile.is_open()) {
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			tempElementTag.resize(openElements + 1);
			tempElementTag[openElements] = elementTag;
			openElements += 1;
			outFile << "<" << elementTag;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x549ab
cmpl $0x0, 0x200(%rbx)
jle 0x54948
xorl %ebp, %ebp
leaq 0x30ac(%rip), %r15      # 0x579da
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7400
incl %ebp
cmpl 0x200(%rbx), %ebp
jl 0x5492e
leaq 0x228(%rbx), %rdi
movslq 0x208(%rbx), %rsi
incq %rsi
callq 0x54d64
movslq 0x208(%rbx), %rdi
shlq $0x5, %rdi
addq 0x228(%rbx), %rdi
movq %r14, %rsi
callq 0x7220
incl 0x208(%rbx)
leaq 0xc37(%rip), %rsi       # 0x555bc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7400
movq 0x1a63e(%rip), %rbx     # 0x6eff0
leaq 0x1bef(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x6024(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a5f1(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_end_element_tag()
void XmlWriter::Write_end_element_tag()
	{
		if (outFile.is_open()) {
			outFile << "/>\n";
			tempElementTag.resize(openElements - 1);
			openElements -= 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x54a31
leaq 0x6020(%rip), %rsi      # 0x5aa26
movl $0x3, %edx
movq %rbx, %rdi
callq 0x7400
leaq 0x228(%rbx), %rdi
movslq 0x208(%rbx), %rsi
decq %rsi
callq 0x54d64
decl 0x208(%rbx)
popq %rbx
retq
movq 0x1a5b8(%rip), %rbx     # 0x6eff0
leaq 0x1b69(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x5f9e(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a56b(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_attribute(const std::string outAttribute)
	{
		if (outFile.is_open()) {
			outFile << " " << outAttribute;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x54ab5
leaq 0x335c(%rip), %rsi      # 0x57dee
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7400
movq 0x1a534(%rip), %rbx     # 0x6eff0
leaq 0x1ae5(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x5f1a(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a4e7(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute_string_inline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_attribute_string_inline(const std::string attribute_name, const std::string attribute_value)
	{
		if (outFile.is_open()) {
			outFile << " ";
			outFile << attribute_name + "=\"" + attribute_value + "\"";
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x54c59
leaq 0x32ca(%rip), %rsi      # 0x57dee
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xb036
leaq 0x5ed1(%rip), %rsi      # 0x5aa2a
movq %r15, %rdi
callq 0x7690
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x28(%rsp), %rdi
callq 0x7130
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x54b99
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x54ba0
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa98(%rip), %rsi       # 0x5565b
callq 0x7690
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x54bef
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x54bf6
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7400
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54c2f
callq 0x7370
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x54c3e
callq 0x7370
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x54c4d
callq 0x7370
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1a390(%rip), %rbx     # 0x6eff0
leaq 0x1941(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x5d76(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a343(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54cb3
callq 0x7370
jmp 0x54cb3
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x54cc9
callq 0x7370
jmp 0x54cc9
jmp 0x54cc6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x54cd8
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_string(const std::string outString)
	{
		if (outFile.is_open()) {
			outFile << ">" << outString;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x70e0
testb %al, %al
je 0x54d21
leaq 0x8f6(%rip), %rsi       # 0x555f4
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7400
movq 0x1a2c8(%rip), %rbx     # 0x6eff0
leaq 0x1879(%rip), %rsi      # 0x565a8
movq %rbx, %rdi
callq 0x7390
leaq 0x5cae(%rip), %rsi      # 0x5a9ec
movq %rbx, %rdi
callq 0x7390
movq %rax, %rdi
callq 0x71c0
movq 0x1a27b(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_05.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::array<std::string, 3> array= {"HELLO", "CPLUSPLUS", "PRIMER"};
	std::string s[] = {"hello", "cplusplus", "primer"};
	char c[] = { 'a', 'b', 'c', 'd' };
	int  i[] = { 1 };

	print(i);
	print(c);
	print(s);
	print(array);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd84(%rip), %rsi       # 0x2004
leaq 0xd82(%rip), %rdx       # 0x2009
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
callq 0x1642
leaq -0xd0(%rbp), %r14
leaq -0xc0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd5b(%rip), %rsi       # 0x200a
leaq 0xd5d(%rip), %rdx       # 0x2013
movq %r14, %rdi
callq 0x1642
leaq -0xb0(%rbp), %r14
leaq -0xa0(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xd3c(%rip), %rsi       # 0x2014
leaq 0xd3b(%rip), %rdx       # 0x201a
movq %r14, %rdi
callq 0x1642
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd25(%rip), %rsi       # 0x201b
leaq 0xd23(%rip), %rdx       # 0x2020
leaq -0x90(%rbp), %r15
movq %r15, %rdi
callq 0x1642
leaq -0x70(%rbp), %r14
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd02(%rip), %rsi       # 0x2021
leaq 0xd04(%rip), %rdx       # 0x202a
movq %r14, %rdi
callq 0x1642
leaq -0x50(%rbp), %r14
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xcea(%rip), %rsi       # 0x202b
leaq 0xce9(%rip), %rdx       # 0x2031
movq %r14, %rdi
callq 0x1642
movl $0x64636261, -0x24(%rbp) # imm = 0x64636261
leaq -0x28(%rbp), %rdi
movl $0x1, (%rdi)
callq 0x14b3
leaq -0x24(%rbp), %rdi
callq 0x14f7
leaq -0x90(%rbp), %rdi
callq 0x156f
leaq -0xf0(%rbp), %rdi
callq 0x15d8
movq $-0x60, %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x13a2
movq (%rbx), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %rbx
addq $0x20, %r14
jne 0x138e
movq $-0x60, %rbx
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x13c9
movq (%r12), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %r12
addq $0x20, %rbx
jne 0x13b3
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13e7
movq %rax, %rbx
jmp 0x13f2
movq %rax, %rbx
movq %r15, %r14
cmpq %r14, %r15
je 0x1482
addq $-0x10, %r14
leaq -0x90(%rbp), %r15
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x141a
movq (%r14), %rsi
incq %rsi
callq 0x1090
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %r15, %r14
movq %rax, %r14
jne 0x1406
jmp 0x1482
jmp 0x142e
movq %rax, %rbx
jmp 0x1439
movq %rax, %rbx
movq %r15, %r14
cmpq %r14, %r15
je 0x14ab
addq $-0x10, %r14
leaq -0xf0(%rbp), %r15
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x145d
movq (%r14), %rsi
incq %rsi
callq 0x1090
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %r15, %r14
movq %rax, %r14
jne 0x1449
jmp 0x14ab
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1100
xorl %r14d, %r14d
movq -0xb0(%rbp,%r14), %rdi
leaq (%r12,%r14), %rax
cmpq %rdi, %rax
je 0x14a1
movq (%rax), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x60, %r14
jne 0x1485
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/middle-end/middle-end_main.cpp
// Function: main
int main()
{
    Tree* tree = GetTreeFromFile(tree_tmp_file);
    Optimize(tree);
    WriteToFile(tree, tree_tmp_file);

    DestructTree(tree);
    DeleteTree(tree);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6e37(%rip), %rdi      # 0x90e0
callq 0x249a
movq %rax, %rbx
movq %rax, %rdi
callq 0x2710
movq 0x6e20(%rip), %rsi      # 0x90e0
movq %rbx, %rdi
callq 0x22e4
movq %rbx, %rdi
callq 0x3a79
movq %rbx, %rdi
callq 0x3ad8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/middle-end/tree_optimize.cpp
// Function: CalculateConsts(Tree*, Node*)
void CalculateConsts(Tree* tree, Node* node)
{
    assert(tree);

    if (node == nullptr)
    {
    	return;
    }

    CalculateConsts(tree, node->right);
    CalculateConsts(tree, node->left);

    if (node->type == MATH_TYPE)
    {
        if (node->right->type == NUMB_TYPE && 
        	node->left ->type == NUMB_TYPE)
        {
            CalculateOP(node);
            node->type = NUMB_TYPE;

            free(node->right);
            node->right = nullptr;
            free(node->left);
            node->left = nullptr;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x27b3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x27ae
movq %rdi, %r14
movq 0x20(%rbx), %rsi
callq 0x2740
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2740
cmpl $0xe, (%rbx)
jne 0x27ae
movq 0x20(%rbx), %rax
cmpl $0xf, (%rax)
jne 0x27ae
movq 0x18(%rbx), %rax
cmpl $0xf, (%rax)
jne 0x27ae
movq %rbx, %rdi
callq 0x27d2
movl $0xf, (%rbx)
movq 0x20(%rbx), %rdi
callq 0x2100
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2100
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x285d(%rip), %rdi      # 0x5017
leaq 0x29a7(%rip), %rsi      # 0x5168
leaq 0x29d7(%rip), %rcx      # 0x519f
movl $0xf, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/middle-end/tree_optimize.cpp
// Function: CalculateOP(Node*)
void CalculateOP(Node* node)
{
	assert(node);
	assert(node->type == MATH_TYPE);
	assert(node->left->type == NUMB_TYPE && node->right->type == NUMB_TYPE);

	switch (node->value.op)
	{
		case ADD_OP: node->value.number = node->left->value.number + node->right->value.number; break;
		case SUB_OP: node->value.number = node->left->value.number - node->right->value.number; break;
		case MUL_OP: node->value.number = node->left->value.number * node->right->value.number; break;
		case DIV_OP: node->value.number = node->left->value.number / node->right->value.number; break;

        case EQUAL_OP        : node->value.number = node->left->value.number == node->right->value.number; break;
        case NOT_EQUAL_OP    : node->value.number = node->left->value.number != node->right->value.number; break;
        case LESS_OP         : node->value.number = node->left->value.number <  node->right->value.number; break;
        case GREATER_OP      : node->value.number = node->left->value.number >  node->right->value.number; break;
        case LESS_EQUAL_OP   : node->value.number = node->left->value.number <= node->right->value.number; break;
        case GREATER_EQUAL_OP: node->value.number = node->left->value.number >= node->right->value.number; break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x28b1
cmpl $0xe, (%rdi)
jne 0x28d0
movq 0x18(%rdi), %rdx
cmpl $0xf, (%rdx)
jne 0x2892
movq 0x20(%rdi), %rcx
cmpl $0xf, (%rcx)
jne 0x2892
movl 0x8(%rdi), %eax
cmpq $0x9, %rax
ja 0x2890
leaq 0x292a(%rip), %rsi      # 0x5140
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
movl 0x8(%rcx), %eax
addl 0x8(%rdx), %eax
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
sete %al
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setge %al
jmp 0x288d
movl 0x8(%rcx), %eax
imull 0x8(%rdx), %eax
jmp 0x288d
movl 0x8(%rdx), %eax
cltd
idivl 0x8(%rcx)
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setg %al
jmp 0x288d
movl 0x8(%rdx), %eax
subl 0x8(%rcx), %eax
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setne %al
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setl %al
jmp 0x288d
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setle %al
movl %eax, 0x8(%rdi)
popq %rbp
retq
leaq 0x295c(%rip), %rdi      # 0x51f5
leaq 0x28c8(%rip), %rsi      # 0x5168
leaq 0x291d(%rip), %rcx      # 0x51c4
movl $0x2d, %edx
callq 0x2090
leaq 0x2811(%rip), %rdi      # 0x50c9
leaq 0x28a9(%rip), %rsi      # 0x5168
leaq 0x28fe(%rip), %rcx      # 0x51c4
movl $0x2b, %edx
callq 0x2090
leaq 0x2906(%rip), %rdi      # 0x51dd
leaq 0x288a(%rip), %rsi      # 0x5168
leaq 0x28df(%rip), %rcx      # 0x51c4
movl $0x2c, %edx
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O1/maclellant[P]ReliableGoBackN/client.cpp
// Function: request_func(int, char*, unsigned long, sockaddr_in)
void request_func(int sockfd, char* filename, size_t length, sockaddr_in server)
{
    socklen_t slen = sizeof(server);
    Packet packet = Packet(filename, length, 0, GET);

    if (sendto(sockfd, packet.buffer, PACKET_SIZE, 0, (struct sockaddr*) &server, slen) == -1)
    {
        perror("Error: could not send acknowledge to client\n");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %edi, %ebx
leaq -0x28(%rbp), %r14
movq %rcx, (%r14)
movq %r8, 0x8(%r14)
movzwl %dx, %edx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x3216
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r8
movl $0x10, %r9d
callq 0x2060
cmpq $-0x1, %rax
je 0x2947
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/cond.cc
// Function: main
int main()
{
	unsigned i;
	while (cin >> i)
		grades.push_back(i);

	for (auto grade : grades) {  // for each grade in grades
		// set the initial grade as pass or fail
		string finalgrade = (grade < 60) ?  "fail" : "pass";

		finalgrade = (grade > 90) ? "high pass"
				                  : (grade < 60) ? "fail" : "pass";

		cout << grade << " " + finalgrade << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x2cac(%rip), %rdi      # 0x4fe0
leaq -0x2c(%rbp), %rsi
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23a3
leaq 0x2da6(%rip), %rbx      # 0x50f8
leaq -0x2c(%rbp), %r14
movq 0x2c83(%rip), %r15      # 0x4fe0
movq 0x2d9c(%rip), %rsi      # 0x5100
cmpq 0x2d9d(%rip), %rsi      # 0x5108
je 0x237f
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x2d83(%rip)      # 0x5100
jmp 0x238a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x25ce
movq %r15, %rdi
movq %r14, %rsi
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x235d
movq 0x2d4e(%rip), %r12      # 0x50f8
movq 0x2d4f(%rip), %r15      # 0x5100
cmpq %r15, %r12
je 0x24c8
leaq -0x50(%rbp), %rbx
movl (%r12), %r13d
cmpq $0x3c, %r13
leaq 0xc41(%rip), %r14       # 0x300e
leaq 0xc30(%rip), %rax       # 0x3004
cmovbq %rax, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xc2b(%rip), %rdx       # 0x3012
leaq 0xc1a(%rip), %rax       # 0x3008
cmovbq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x270e
xorl %eax, %eax
cmpq $0x5b, %r13
setae %al
leaq 0xbfc(%rip), %rcx       # 0x3009
cmovaeq %rcx, %r14
movq -0x48(%rbp), %rdx
leaq (%rax,%rax,4), %r8
addq $0x4, %r8
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x2140
movq 0x2b9f(%rip), %rdi      # 0x4fd0
movq %r13, %rsi
callq 0x2090
movq %rax, %r13
leaq -0x70(%rbp), %rdi
leaq 0xbcc(%rip), %rsi       # 0x3013
movq %rbx, %rdx
callq 0x253c
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %r13, %rdi
callq 0x2120
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x24a2
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2110
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x24bb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
addq $0x4, %r12
cmpq %r15, %r12
jne 0x23be
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24db
movq %rax, %rbx
jmp 0x24fc
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x24fc
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2110
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2515
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksraj123[P]RAW12-to-bitmap-AVI/src/ImageLoader.cpp
// Function: ImageLoader::LoadImage()
void ImageLoader::LoadImage()
{
    _intputFile.open(_filePath, std::ios::binary);
    if(!_intputFile)
    {
        std::cerr << "Error: File cannot be opened\b\tExiting" << std::endl;
        exit(1);
    }
        _intputFile.read(fileData, INPUT_SIZE);
    for (int itrFileData = 0, itrCfa = 0; itrFileData < INPUT_SIZE, itrCfa < TOTAL_PIX; itrFileData += 3, itrCfa+=2)
    {
        cfa[itrCfa] = fileData[itrFileData];
        cfa[itrCfa + 1] = Sensel(fileData[itrFileData + 1], fileData[itrFileData + 2]);
    }
    _intputFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
leaq 0x8(%rdi), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x2140
movq 0x28(%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%r14,%rax)
jne 0x2e5b
movq (%r14), %rsi
movl $0x1200000, %edx        # imm = 0x1200000
movq %rbx, %rdi
callq 0x21c0
movq $-0x2, %rax
xorl %ecx, %ecx
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
movq 0x230(%r14), %rsi
movb %dl, 0x2(%rsi,%rax)
movq (%r14), %rdx
movb 0x1(%rdx,%rcx), %sil
movb 0x2(%rdx,%rcx), %dl
shrb $0x4, %dl
shlb $0x4, %sil
orb %dl, %sil
movq 0x230(%r14), %rdx
movb %sil, 0x3(%rdx,%rax)
addq $0x3, %rcx
addq $0x2, %rax
cmpq $0xbffffe, %rax         # imm = 0xBFFFFE
jb 0x2e0c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
movq 0x418e(%rip), %rdi      # 0x6ff0
leaq 0x2411(%rip), %rsi      # 0x527a
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/ksraj123[P]RAW12-to-bitmap-AVI/src/OutputWriter.cpp
// Function: OutputWriter::Print5by5tile(unsigned char*)
void OutputWriter::Print5by5tile(uint8_t* array)
{
    for (int row = 0; row < 5; ++row)
    {
        for (int index = 0; index < 5; ++index)
        {
            std::cout << (int)array[row * IMAGE_WIDTH + index] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x4099(%rip), %r14      # 0x6fd0
leaq 0x23da(%rip), %r15      # 0x5318
movq $-0x5, %r13
movzbl 0x5(%rbx,%r13), %esi
movq %r14, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
incq %r13
jne 0x2f45
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
incq %r12
addq $0x1000, %rbx           # imm = 0x1000
cmpq $0x5, %r12
jne 0x2f3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq