LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]MQSim/src/utils/CMRRandomGenerator.cpp
// Function: Utils::CMRRandomGenerator::Advance(long, int)
void CMRRandomGenerator::Advance(int64_t n, int32_t e)
	{
		int64_t B[2][3][3];

		int64_t S[2][3];
		int64_t M[2];

		for (int i = 0; i <= 1; i++) {
			m_ftoi(a[i], B[i], m[i]);
			v_ftoi(s[i], S[i], m[i]);
			M[i] = (int64_t)(m[i]);
		}

		while (e-- != 0) {
			for (int i = 0; i <= 1; i++) {
				mm_mul(B[i], B[i], B[i], M[i]);
			}
		}

		while (n != 0) {
			if ((n & 1) != 0) {
				for (int i = 0; i <= 1; i++) {
					mv_mul(B[i], S[i], S[i], M[i]);
				}
			}
			n >>= 1;
			if (n != 0) {
				for (int i = 0; i <= 1; i++) {
					mm_mul(B[i], B[i], B[i], M[i]);
				}
			}
		}

		for (int i = 0; i <= 1; i++) {
			v_itof(S[i], s[i], M[i]);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %edx, %ebp
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %r13
leaq 0x26e0d(%rip), %rbx     # 0x66b80
xorl %r14d, %r14d
movq %rdi, 0x28(%rsp)
cmpq $0x10, %r14
je 0x3fddc
leaq 0x26e88(%rip), %r12     # 0x66c10
movsd (%r14,%r12), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3ffc2
movsd (%r14,%r12), %xmm0
movq %r15, %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x40010
leaq 0x26e5a(%rip), %rax     # 0x66c10
cvttsd2si (%r14,%rax), %rax
movq %rax, 0x10(%rsp,%r14)
addq $0x8, %r14
addq $0x18, %r12
movq %r12, 0x8(%rsp)
addq $0x18, %r15
addq $0x48, %r13
addq $0x48, %rbx
jmp 0x3fd7b
leaq 0x60(%rsp), %r14
subl $0x1, %ebp
jb 0x3fe0e
movq %r14, %rbx
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x3fde1
movq 0x10(%rsp,%r15,8), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4004a
incq %r15
addq $0x48, %rbx
jmp 0x3fdec
leaq 0x60(%rsp), %r12
leaq 0x30(%rsp), %r13
movq 0x20(%rsp), %rbp
testq %rbp, %rbp
je 0x3fe93
testb $0x1, %bpl
jne 0x3fe5f
movq %rbp, %r14
sarq %r14
cmpq $0x1, %rbp
movq %r14, %rbp
je 0x3fe1d
movq %r12, %rbx
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x3fe8e
movq 0x10(%rsp,%r15,8), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4004a
incq %r15
addq $0x48, %rbx
jmp 0x3fe3d
movq %r12, %rbx
movq %r13, %r15
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x3fe28
movq 0x10(%rsp,%r14,8), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x400cc
incq %r14
addq $0x18, %r15
addq $0x48, %rbx
jmp 0x3fe68
movq %r14, %rbp
jmp 0x3fe1d
leaq 0x30(%rsp), %rbx
xorl %r14d, %r14d
movq 0x28(%rsp), %r15
cmpq $0x2, %r14
je 0x3fec3
movq 0x10(%rsp,%r14,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4011a
incq %r14
addq $0x18, %r15
addq $0x18, %rbx
jmp 0x3fea0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]MQSim/src/utils/CMRRandomGenerator.cpp
// Function: Utils::CMRRandomGenerator::NextDouble()
double CMRRandomGenerator::NextDouble()
	{
		double p1 = mod(a12 * s[0][1] + a13 * s[0][0], m1);
		s[0][0] = s[0][1];
		s[0][1] = s[0][2];
		s[0][2] = p1;
		double p2 = mod(a21 * s[1][2] + a23 * s[1][0], m2);
		s[1][0] = s[1][1];
		s[1][1] = s[1][2];
		s[1][2] = p2;
		double p = p1 - p2;
		if (p < 0.0) {
			p += m1;
		}

		return (p + 1) * norm;
	}

// Assembly:
movsd 0x225ba(%rip), %xmm1    # 0x62498
movupd (%rdi), %xmm3
movupd 0x8(%rdi), %xmm2
movupd 0x20(%rdi), %xmm0
movsd 0x225bc(%rip), %xmm4    # 0x624b0
movsd 0x225ac(%rip), %xmm5    # 0x624a8
movupd %xmm2, (%rdi)
movhpd 0x225b8(%rip), %xmm4    # xmm4 = xmm4[0],mem[0]
movhpd 0x18(%rdi), %xmm3       # xmm3 = xmm3[0],mem[0]
mulpd %xmm4, %xmm3
movhpd 0x2259f(%rip), %xmm5    # xmm5 = xmm5[0],mem[0]
shufpd $0x2, %xmm0, %xmm2      # xmm2 = xmm2[0],xmm0[1]
mulpd %xmm5, %xmm2
addpd %xmm3, %xmm2
movapd %xmm1, %xmm3
movhpd 0x2256e(%rip), %xmm3    # xmm3 = xmm3[0],mem[0]
movapd %xmm2, %xmm4
divpd %xmm3, %xmm4
cvttsd2si %xmm4, %rax
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
cvttsd2si %xmm4, %rcx
cvtsi2sd %rax, %xmm4
cvtsi2sd %rcx, %xmm5
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
mulpd %xmm3, %xmm4
subpd %xmm4, %xmm2
xorpd %xmm4, %xmm4
movapd %xmm2, %xmm5
cmpltpd %xmm4, %xmm5
addpd %xmm2, %xmm3
andpd %xmm5, %xmm3
andnpd %xmm2, %xmm5
orpd %xmm3, %xmm5
movlpd %xmm5, 0x10(%rdi)
movupd %xmm0, 0x18(%rdi)
pshufd $0xee, %xmm5, %xmm2     # xmm2 = xmm5[2,3,2,3]
subsd %xmm2, %xmm5
addsd %xmm5, %xmm1
xorpd %xmm3, %xmm3
movapd %xmm5, %xmm0
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm5, %xmm0
orpd %xmm1, %xmm0
addsd 0x5b6d(%rip), %xmm0     # 0x45b20
movlpd %xmm2, 0x28(%rdi)
mulsd 0x224d0(%rip), %xmm0    # 0x62490
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x48, %rsp
movq %rdx, %r8
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x400b4
imulq $0x18, %r9, %rax
leaq (%rsp,%rax), %r10
movq %rsi, %r11
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x400ab
leaq (%r10,%rbx,8), %r14
movq %r11, %r15
xorl %r12d, %r12d
xorl %edx, %edx
cmpq $0x3, %r12
je 0x4009f
movq (%r15), %rax
imulq (%rdi,%r12,8), %rax
addq %rdx, %rax
cqto
idivq %rcx
incq %r12
addq $0x18, %r15
jmp 0x40080
movq %rdx, (%r14)
incq %rbx
addq $0x8, %r11
jmp 0x4006e
incq %r9
addq $0x18, %rdi
jmp 0x4005b
movq %rsp, %rdi
movq %r8, %rsi
callq 0x40134
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]MQSim/src/utils/CMRRandomGenerator.h
// Function: Utils::CMRRandomGenerator::mv_mul(long (*) [3], long*, long*, long)
static void mv_mul(int64_t a[][3], int64_t* u, int64_t* v, int64_t m)
			{
				int64_t w[3];
				for (int i = 0; i <= 2; i++) {
					w[i] = 0;
					for (int j = 0; j <= 2; j++) {
						w[i] = (a[i][j] * u[j] + w[i]) % m;
					}
				}
				v_copy(w, v);
			}

// Assembly:
subq $0x18, %rsp
movq %rdx, %r8
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x4010a
xorl %r10d, %r10d
xorl %edx, %edx
cmpq $0x3, %r10
je 0x400fd
movq (%rsi,%r10,8), %rax
imulq (%rdi,%r10,8), %rax
addq %rdx, %rax
cqto
idivq %rcx
incq %r10
jmp 0x400e1
movq %rdx, (%rsp,%r9,8)
incq %r9
addq $0x18, %rdi
jmp 0x400d6
movq %rsp, %rdi
movq %r8, %rsi
callq 0x40160
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x401bb
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 0x401c0
jp 0x401c0
movsd 0x5965(%rip), %xmm2     # 0x45b20
movapd %xmm2, %xmm0
retq
pushq $0x2
popq %rax
movsd 0x5955(%rip), %xmm1     # 0x45b20
movapd %xmm0, %xmm2
cvtsi2sd %eax, %xmm4
ucomisd %xmm4, %xmm3
jb 0x401bb
movapd %xmm0, %xmm5
subsd %xmm4, %xmm5
addsd %xmm1, %xmm5
mulsd %xmm5, %xmm2
divsd %xmm4, %xmm2
incl %eax
jmp 0x401cf
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x26775(%rip)     # 0x66c94
movq 0x26772(%rip), %rax     # 0x66c98
cmpq %rax, 0x26773(%rip)     # 0x66ca0
je 0x40536
movq %rax, 0x2676a(%rip)     # 0x66ca0
movq 0x26773(%rip), %rax     # 0x66cb0
cmpq %rax, 0x26774(%rip)     # 0x66cb8
je 0x4054d
movq %rax, 0x2676b(%rip)     # 0x66cb8
movq 0x26774(%rip), %rax     # 0x66cc8
cmpq %rax, 0x26775(%rip)     # 0x66cd0
je 0x40564
movq %rax, 0x2676c(%rip)     # 0x66cd0
pushq %r15
pushq %r14
pushq %rbx
leaq 0x266c0(%rip), %rdi     # 0x66c30
callq 0x41136
leaq 0x266cc(%rip), %rdi     # 0x66c48
callq 0x41136
leaq 0x266d8(%rip), %rdi     # 0x66c60
callq 0x41136
leaq 0x266e4(%rip), %rdi     # 0x66c78
callq 0x41136
xorl %ebx, %ebx
movl 0x2673f(%rip), %eax     # 0x66ce0
cmpq %rax, %rbx
jae 0x40615
xorl %r14d, %r14d
movl 0x26735(%rip), %eax     # 0x66ce4
cmpq %rax, %r14
jae 0x405fb
movl 0x2672e(%rip), %eax     # 0x66ce8
xorl %r15d, %r15d
movl %eax, %ecx
movq 0x26662(%rip), %rdx     # 0x66c28
movq (%rdx,%rbx,8), %rdx
movq (%rdx,%r14,8), %rdi
cmpq %rcx, %r15
jae 0x405ec
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x405e7
callq 0x7430
movl 0x26701(%rip), %eax     # 0x66ce8
incq %r15
jmp 0x405bd
testq %rdi, %rdi
je 0x405f6
callq 0x7430
incq %r14
jmp 0x405a9
movq 0x26626(%rip), %rax     # 0x66c28
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x40610
callq 0x7430
incq %rbx
jmp 0x4059b
movq 0x2660c(%rip), %rdi     # 0x66c28
testq %rdi, %rdi
popq %rbx
popq %r14
popq %r15
jne 0x7430
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x25d97(%rip)     # 0x66c94
jne 0x40f17
cmpl $0x2, 0x25d8a(%rip)     # 0x66c90
jae 0x40f17
movq 0x25da1(%rip), %rax     # 0x66cb0
movzwl %di, %ecx
movq (%rax,%rcx,8), %rax
retq
pushq %rbx
movq 0x210d1(%rip), %rbx     # 0x61ff0
leaq 0x3662(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x78a3(%rip), %rsi      # 0x487d8
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x21084(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x25d33(%rip)     # 0x66c94
jne 0x40f7b
cmpl $0x2, 0x25d26(%rip)     # 0x66c90
jae 0x40f7b
movq 0x25d55(%rip), %rax     # 0x66cc8
movzwl %di, %ecx
movq (%rax,%rcx,8), %rax
retq
pushq %rbx
movq 0x2106d(%rip), %rbx     # 0x61ff0
leaq 0x35fe(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x783f(%rip), %rsi      # 0x487d8
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x21020(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x25ccf(%rip)     # 0x66c94
jne 0x40ff0
cmpl $0x2, 0x25cc2(%rip)     # 0x66c90
jae 0x40ff0
movq 0x25cf1(%rip), %rax     # 0x66cc8
movzwl %di, %ecx
shll $0x3, %ecx
movq (%rax,%rcx), %rax
movq 0x25cc8(%rip), %rdx     # 0x66cb0
subq (%rdx,%rcx), %rax
incq %rax
retq
pushq %rbx
movq 0x20ff8(%rip), %rbx     # 0x61ff0
leaq 0x3589(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x77ca(%rip), %rsi      # 0x487d8
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x20fab(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x25c5b(%rip)     # 0x66c94
jne 0x41072
movl 0x25c4f(%rip), %eax     # 0x66c90
cmpl $0x1, %eax
je 0x41052
testl %eax, %eax
jne 0x41072
movq 0x25ca7(%rip), %rax     # 0x66cf8
retq
movq 0x25c6f(%rip), %rax     # 0x66cc8
movzwl %di, %ecx
shll $0x3, %ecx
movq (%rax,%rcx), %rax
movq 0x25c46(%rip), %rdx     # 0x66cb0
subq (%rdx,%rcx), %rax
incq %rax
retq
pushq %rbx
movq 0x20f76(%rip), %rbx     # 0x61ff0
leaq 0x3507(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x7748(%rip), %rsi      # 0x487d8
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x20f29(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x25bd9(%rip)     # 0x66c94
jne 0x410e6
movl 0x25bcd(%rip), %eax     # 0x66c90
testl %eax, %eax
je 0x410db
cmpl $0x1, %eax
jne 0x410e6
movzwl %di, %eax
shll $0x3, %eax
addq 0x25bbf(%rip), %rax     # 0x66c98
jmp 0x410e2
leaq 0x25c0e(%rip), %rax     # 0x66cf0
movq (%rax), %rax
retq
pushq %rbx
movq 0x20f02(%rip), %rbx     # 0x61ff0
leaq 0x3493(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x76d4(%rip), %rsi      # 0x487d8
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x20eb5(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movapd %xmm0, (%rsp)
divsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1d19(%rip), %xmm0     # 0x43050
cvttsd2si %xmm0, %r14
andq %rcx, %r14
xorl %r15d, %r15d
orq %rax, %r14
cmovgq %r14, %r15
movsd 0x47cf(%rip), %xmm1     # 0x45b20
subq $0x1, %r15
jb 0x41371
movq %rbx, %rdi
movsd %xmm1, 0x18(%rsp)
callq 0x411d0
movsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
jmp 0x41351
cvtsi2sd %r14, %xmm0
movapd (%rsp), %xmm2
xorpd 0x5dbd(%rip), %xmm2     # 0x47140
divsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm1, %xmm0
callq 0x72d0
mulsd (%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4146f
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x7442(%rip), %xmm0     # 0x48810
addsd %xmm1, %xmm0
addsd 0x4746(%rip), %xmm1     # 0x45b20
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x413ee
sqrtsd %xmm0, %xmm0
jmp 0x413f3
callq 0x72c0
movsd 0x4725(%rip), %xmm1     # 0x45b20
subsd %xmm0, %xmm1
mulsd 0x5d59(%rip), %xmm1     # 0x47160
movapd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
callq 0x411d0
movsd 0x4703(%rip), %xmm2     # 0x45b20
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 0x73ca(%rip), %xmm0     # 0x48818
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x411d0
callq 0x72d0
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x71b0
movq %rax, %rbx
leaq 0x73bf(%rip), %rsi      # 0x48840
movq %rax, %rdi
callq 0x74b0
movq 0x20b30(%rip), %rsi     # 0x61fc0
movq 0x20ad9(%rip), %rdx     # 0x61f70
movq %rbx, %rdi
callq 0x7590
movq %rax, %r14
movq %rbx, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x75d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x414d3
jnp 0x414dd
movsd 0x10(%rbx), %xmm0
jmp 0x41587
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rbx, %rdi
callq 0x411d0
movapd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x411d0
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd %xmm1, %xmm1
addpd 0x731c(%rip), %xmm1     # 0x48830
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
ucomisd 0x45ec(%rip), %xmm0     # 0x45b20
jae 0x414e8
movapd %xmm1, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
callq 0x72d0
mulsd 0x72d1(%rip), %xmm0     # 0x48820
divsd 0x20(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41565
sqrtsd %xmm0, %xmm0
jmp 0x4156a
callq 0x72c0
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_O2/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 0x4567(%rip), %xmm1     # 0x45b20
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
pushq $-0x1
popq %r14
movq %rbx, %rdi
callq 0x411d0
incq %r14
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x415c6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x71fe(%rip), %xmm0     # 0x48810
addsd %xmm1, %xmm0
addsd 0x4502(%rip), %xmm1     # 0x45b20
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41632
sqrtsd %xmm0, %xmm0
jmp 0x41637
callq 0x72c0
movsd 0x44e1(%rip), %xmm1     # 0x45b20
subsd %xmm0, %xmm1
mulsd 0x5b15(%rip), %xmm1     # 0x47160
movapd %xmm1, (%rsp)
movq %rbx, %rdi
callq 0x411d0
movsd 0x44c0(%rip), %xmm2     # 0x45b20
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 0x5aaf(%rip), %xmm0     # 0x47140
movapd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x411d0
callq 0x72d0
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_O2/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
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
testq %rsi, %rsi
cmovleq %r14, %rbx
subq $0x1, %rbx
jb 0x416ff
movq %r15, %rdi
callq 0x411d0
xorl %eax, %eax
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addq %rax, %r14
jmp 0x416dd
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps 0x5a23(%rip), %xmm0     # 0x47140
callq 0x75f0
movsd %xmm0, 0x10(%rsp)
movsd 0x43f0(%rip), %xmm0     # 0x45b20
pushq $-0x1
popq %r14
ucomisd 0x10(%rsp), %xmm0
jb 0x41765
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x411d0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r14
jmp 0x41734
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
callq 0x411d0
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 0x418e3
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 0x41913
sqrtsd %xmm4, %xmm0
jmp 0x41921
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 0x41927
sqrtsd %xmm0, %xmm5
jmp 0x41936
movapd %xmm4, %xmm0
callq 0x72c0
movsd (%rsp), %xmm5
subsd %xmm0, %xmm5
jmp 0x4193a
callq 0x72c0
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm5
addsd %xmm4, %xmm5
movapd %xmm5, %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
callq 0x7190
leaq 0x70(%rbx), %rdi
callq 0x70d0
movl %eax, %ebp
testb %al, %al
je 0x419bb
leaq 0x6eed(%rip), %rsi      # 0x48891
movq %rbx, %rdi
callq 0x7360
andq $0x0, 0x200(%rbx)
andl $0x0, 0x208(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x70d0
testb %al, %al
je 0x41a9a
xorl %ebp, %ebp
leaq 0x3ee3(%rip), %r15      # 0x458ea
cmpl 0x200(%rbx), %ebp
jge 0x41a1e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7360
incl %ebp
jmp 0x41a07
leaq 0x210(%rbx), %rdi
movslq 0x204(%rbx), %rsi
incq %rsi
callq 0x420b2
leaq 0x1b57(%rip), %rsi      # 0x43592
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
movq %r14, %rsi
callq 0x7310
leaq 0x6ea2(%rip), %rsi      # 0x488f7
movq %rax, %rdi
callq 0x7360
movslq 0x204(%rbx), %rdi
shlq $0x5, %rdi
addq 0x210(%rbx), %rdi
movq %r14, %rsi
callq 0x7210
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 0x2054f(%rip), %rbx     # 0x61ff0
leaq 0x2ae0(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x6e05(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x20502(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute_string(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(const std::string attribute_name, const std::string attribute_value)
	{
		if (outFile.is_open()) {
			for (int i = 0; i < indent + 1; i++) {
				outFile << "\t";
			}

			outFile << " <" << attribute_name + ">" + attribute_value + "</" << attribute_name + ">\n";
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x70, %rdi
callq 0x70d0
testb %al, %al
je 0x41bd8
xorl %ebp, %ebp
leaq 0x3ddc(%rip), %r12      # 0x458ea
cmpl 0x200(%r15), %ebp
jg 0x41b26
movq %r15, %rdi
movq %r12, %rsi
callq 0x7360
incl %ebp
jmp 0x41b0e
leaq 0x1a64(%rip), %rsi      # 0x43591
movq %r15, %rdi
callq 0x7360
movq %rax, %r15
leaq 0x1a8b(%rip), %rdx      # 0x435ca
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x11c18
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x11c6d
leaq 0x6d8d(%rip), %rdx      # 0x488f3
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x9b29
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x7310
movq %rax, %r14
leaq 0x6d6b(%rip), %rdx      # 0x488f7
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x11c18
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7310
movq %rsp, %rdi
callq 0x7678
leaq 0x40(%rsp), %rdi
callq 0x7678
leaq 0x20(%rsp), %rdi
callq 0x7678
leaq 0x60(%rsp), %rdi
callq 0x7678
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20411(%rip), %rbx     # 0x61ff0
leaq 0x29a2(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x6cc7(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x203c4(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7678
jmp 0x41c2b
jmp 0x41c28
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x7678
jmp 0x41c3a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7678
jmp 0x41c49
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x7678
movq %rbx, %rdi
callq 0x75d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x70d0
testb %al, %al
je 0x41d08
movl 0x200(%rbx), %eax
decl %eax
movl %eax, 0x200(%rbx)
xorl %ebp, %ebp
leaq 0x3c5f(%rip), %r14      # 0x458ea
cmpl %eax, %ebp
jge 0x41ca4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7360
incl %ebp
movl 0x200(%rbx), %eax
jmp 0x41c8b
leaq 0x6c48(%rip), %rsi      # 0x488f3
movq %rbx, %rdi
callq 0x7360
leaq 0x210(%rbx), %r14
movslq 0x204(%rbx), %rcx
movq 0x210(%rbx), %rdx
shlq $0x5, %rcx
leaq (%rdx,%rcx), %rsi
addq $-0x20, %rsi
movq %rax, %rdi
callq 0x7310
leaq 0x6c14(%rip), %rsi      # 0x488f7
movq %rax, %rdi
callq 0x7360
movslq 0x204(%rbx), %rsi
decq %rsi
movq %r14, %rdi
callq 0x420b2
decl 0x204(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x202e1(%rip), %rbx     # 0x61ff0
leaq 0x2872(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x6b97(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x20294(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
addq $0x70, %rdi
callq 0x70d0
testb %al, %al
je 0x41de0
xorl %ebp, %ebp
leaq 0x3b7d(%rip), %r15      # 0x458ea
cmpl 0x200(%r14), %ebp
jge 0x41d85
movq %r14, %rdi
movq %r15, %rsi
callq 0x7360
incl %ebp
jmp 0x41d6d
leaq 0x228(%r14), %rdi
movslq 0x208(%r14), %rsi
incq %rsi
callq 0x420b2
movslq 0x208(%r14), %rdi
shlq $0x5, %rdi
addq 0x228(%r14), %rdi
movq %rbx, %rsi
callq 0x7210
incl 0x208(%r14)
leaq 0x17cf(%rip), %rsi      # 0x43592
movq %r14, %rdi
callq 0x7360
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7310
movq 0x20209(%rip), %rbx     # 0x61ff0
leaq 0x279a(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x6abf(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x201bc(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x70d0
testb %al, %al
je 0x41e60
leaq 0x6abc(%rip), %rsi      # 0x488f6
movq %rbx, %rdi
callq 0x7360
leaq 0x228(%rbx), %rdi
movslq 0x208(%rbx), %rsi
decq %rsi
callq 0x420b2
decl 0x208(%rbx)
popq %rbx
retq
movq 0x20189(%rip), %rbx     # 0x61ff0
leaq 0x271a(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x6a3f(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x2013c(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
addq $0x70, %rdi
callq 0x70d0
testb %al, %al
je 0x41eda
leaq 0x3e3e(%rip), %rsi      # 0x45cfe
movq %r14, %rdi
callq 0x7360
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7310
movq 0x2010f(%rip), %rbx     # 0x61ff0
leaq 0x26a0(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x69c5(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x200c2(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x70d0
testb %al, %al
je 0x41fc4
leaq 0x3db6(%rip), %rsi      # 0x45cfe
movq %rbx, %rdi
callq 0x7360
leaq 0x69a3(%rip), %rdx      # 0x488fa
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x11c18
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x11c6d
leaq 0x16cb(%rip), %rdx      # 0x43649
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9b29
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7310
leaq 0x28(%rsp), %rdi
callq 0x7678
leaq 0x8(%rsp), %rdi
callq 0x7678
leaq 0x48(%rsp), %rdi
callq 0x7678
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20025(%rip), %rbx     # 0x61ff0
leaq 0x25b6(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x68db(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x1ffd8(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7678
jmp 0x42017
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7678
jmp 0x42026
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7678
movq %rbx, %rdi
callq 0x75d0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
addq $0x70, %rdi
callq 0x70d0
testb %al, %al
je 0x42070
leaq 0x1574(%rip), %rsi      # 0x435ca
movq %r14, %rdi
callq 0x7360
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7310
movq 0x1ff79(%rip), %rbx     # 0x61ff0
leaq 0x250a(%rip), %rsi      # 0x44588
movq %rbx, %rdi
callq 0x7360
leaq 0x682f(%rip), %rsi      # 0x488bc
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
movq 0x1ff2c(%rip), %rdi     # 0x61fd0
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xd8, %rsp
leaq 0xdf1(%rip), %rsi       # 0x2004
leaq -0xf0(%rbp), %r14
leaq -0x90(%rbp), %rdx
movq %r14, %rdi
callq 0x1030
leaq -0xd0(%rbp), %r15
leaq 0xdd3(%rip), %rsi       # 0x200a
leaq -0x1c(%rbp), %rdx
movq %r15, %rdi
callq 0x1030
leaq -0xb0(%rbp), %r15
leaq 0xdc3(%rip), %rsi       # 0x2014
leaq -0x24(%rbp), %rdx
movq %r15, %rdi
callq 0x1030
leaq 0xdb7(%rip), %rsi       # 0x201b
leaq -0x90(%rbp), %r14
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
callq 0x1030
leaq -0x70(%rbp), %r15
leaq 0xd9f(%rip), %rsi       # 0x2021
leaq -0x24(%rbp), %rdx
movq %r15, %rdi
callq 0x1030
leaq -0x50(%rbp), %r15
leaq 0xd92(%rip), %rsi       # 0x202b
leaq -0x1d(%rbp), %rdx
movq %r15, %rdi
callq 0x1030
movl $0x64636261, -0x1c(%rbp) # imm = 0x64636261
leaq -0x24(%rbp), %rdi
movl $0x1, (%rdi)
callq 0x137f
leaq -0x1c(%rbp), %rdi
callq 0x13c1
leaq -0x90(%rbp), %rdi
callq 0x1403
leaq -0xf0(%rbp), %rdi
callq 0x1445
pushq $0x40
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x90, %rdi
callq 0x1040
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x12df
leaq -0xf0(%rbp), %rdi
callq 0x1488
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1317
movq %rax, %rbx
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1040
cmpq %r14, %r15
jne 0x131a
jmp 0x136b
movq %rax, %rbx
jmp 0x136b
jmp 0x1334
movq %rax, %rbx
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1040
cmpq %r14, %r15
jne 0x1337
jmp 0x1377
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x90, %rdi
callq 0x1040
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1351
leaq -0xf0(%rbp), %rdi
callq 0x1488
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2492
movq %rax, %rbx
movq %rax, %rdi
callq 0x26d4
movq 0x6e20(%rip), %rsi      # 0x90e0
movq %rbx, %rdi
callq 0x22e4
movq %rbx, %rdi
callq 0x3942
movq %rbx, %rdi
callq 0x399f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2774
movq %rsi, %rbx
testq %rsi, %rsi
je 0x276f
movq %rdi, %r14
movq 0x20(%rbx), %rsi
callq 0x2702
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2702
cmpl $0xe, (%rbx)
jne 0x276f
movq 0x20(%rbx), %rax
cmpl $0xf, (%rax)
jne 0x276f
movq 0x18(%rbx), %rax
cmpl $0xf, (%rax)
jne 0x276f
movq %rbx, %rdi
callq 0x2791
movl $0xf, (%rbx)
movq 0x20(%rbx), %rdi
callq 0x2100
andq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2100
andq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x289c(%rip), %rdi      # 0x5017
leaq 0x29e6(%rip), %rsi      # 0x5168
leaq 0x2a16(%rip), %rcx      # 0x519f
pushq $0xf
popq %rdx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x286a
cmpl $0xe, (%rdi)
jne 0x2883
movq 0x18(%rdi), %rdx
cmpl $0xf, (%rdx)
jne 0x2851
movq 0x20(%rdi), %rcx
cmpl $0xf, (%rcx)
jne 0x2851
movl 0x8(%rdi), %eax
cmpq $0x9, %rax
ja 0x284f
leaq 0x296b(%rip), %rsi      # 0x5140
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
movl 0x8(%rcx), %eax
addl 0x8(%rdx), %eax
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
sete %al
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setge %al
jmp 0x284c
movl 0x8(%rcx), %eax
imull 0x8(%rdx), %eax
jmp 0x284c
movl 0x8(%rdx), %eax
cltd
idivl 0x8(%rcx)
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setg %al
jmp 0x284c
movl 0x8(%rdx), %eax
subl 0x8(%rcx), %eax
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setne %al
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setl %al
jmp 0x284c
movl 0x8(%rdx), %edx
xorl %eax, %eax
cmpl 0x8(%rcx), %edx
setle %al
movl %eax, 0x8(%rdi)
popq %rbp
retq
leaq 0x299d(%rip), %rdi      # 0x51f5
leaq 0x2909(%rip), %rsi      # 0x5168
leaq 0x295e(%rip), %rcx      # 0x51c4
pushq $0x2d
jmp 0x289a
leaq 0x2858(%rip), %rdi      # 0x50c9
leaq 0x28f0(%rip), %rsi      # 0x5168
leaq 0x2945(%rip), %rcx      # 0x51c4
pushq $0x2b
jmp 0x289a
leaq 0x2953(%rip), %rdi      # 0x51dd
leaq 0x28d7(%rip), %rsi      # 0x5168
leaq 0x292c(%rip), %rcx      # 0x51c4
pushq $0x2c
popq %rdx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %r8
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2d8e
pushq $0x10
popq %r9
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r8
callq 0x2050
cmpq $-0x1, %rax
je 0x2747
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e3(%rip), %rdi       # 0x3131
callq 0x2110
movl %ebx, %edi
callq 0x2200
pushq $0x1
popq %rdi
callq 0x2170