LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::m_deleteConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void VrsNtripClient::m_deleteConnection(string staname) {
	map<string, stream_t*>::iterator streamItr;
	map<string, rtcm_t*>::iterator rtcmItr;
	map<string, VrsStaItem>::iterator vrsItr;

	streamItr = m_streams.find(staname);
	rtcmItr = m_rtcms.find(staname);
	vrsItr = m_stas.find(staname);

	if (streamItr != m_streams.end()) {
		strclose((*streamItr).second);
		free((*streamItr).second);
		m_streams.erase(streamItr);
	}
	if (rtcmItr != m_rtcms.end()) {
		free_rtcm((*rtcmItr).second);
		free((*rtcmItr).second);
		m_rtcms.erase(rtcmItr);
	}
	if (vrsItr != m_stas.end())
		m_stas.erase(vrsItr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2068(%rdi), %r14
movq %r14, %rdi
callq 0x6414e
movq %rax, %r15
leaq 0x2098(%rbx), %rdi
movq %rdi, -0x30(%rbp)
movq %r12, %rsi
callq 0x641ec
movq %rax, %r13
leaq 0x20c8(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r12, %rsi
callq 0x6423c
movq %rax, %r12
leaq 0x2070(%rbx), %rax
cmpq %rax, %r15
je 0x6335e
movq 0x40(%r15), %rdi
callq 0x58f13
movq 0x40(%r15), %rdi
callq 0x87a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6428c
leaq 0x20a0(%rbx), %rax
cmpq %rax, %r13
je 0x63388
movq 0x40(%r13), %rdi
callq 0x38c6c
movq 0x40(%r13), %rdi
callq 0x87a0
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x642cc
addq $0x20d0, %rbx           # imm = 0x20D0
cmpq %rbx, %r12
je 0x633ae
movq -0x38(%rbp), %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6430c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsinit(double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsinit(double* x,GLSEPH& eph){
	int i;
	for (i = 0; i < 3; i++)
		x[i] = eph.pos[i];
	for (i = 3; i < 6; i++)
		x[i] = eph.vel[i - 3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movsd 0x30(%rdx,%rax,8), %xmm0
movsd %xmm0, (%rsi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x659a6
xorl %eax, %eax
movsd 0x48(%rdx,%rax,8), %xmm0
movsd %xmm0, 0x18(%rsi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x659bc
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsrkf4(double, double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsrkf4(double h, double* x, GLSEPH& eph){
	int i, j;
	double coef[4], xj[6], acc[6], funct[6];
	coef[0] = h / 2;
	coef[1] = h / 2;
	coef[2] = h;
	coef[3] = h;
	for (i = 0; i < 6; i++)
		xj[i] = x[i];
	glsfright(xj, acc, eph);
	for (i = 0; i < 6; i++)
		funct[i] = xj[i];
	for (j = 0; j < 3; j++) {
		for (i = 0; i < 6; i++) {
			xj[i] = x[i] + coef[j] * acc[i];
			funct[i] = funct[i] + coef[j + 1] * acc[i] / 3.0;
		}
		glsfright(xj, acc, eph);
	}
	for (i = 0; i < 6; i++)
		x[i] = funct[i] + h * acc[i] / 6.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movsd 0x6282(%rip), %xmm1     # 0x6bc78
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd %xmm1, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
movsd %xmm0, -0x50(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm0, -0x48(%rbp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
leaq -0xf0(%rbp), %r15
movaps %xmm0, (%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm2, 0x20(%r15)
leaq -0xc0(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x65e74
movapd (%r15), %xmm0
movapd 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movaps %xmm2, -0x70(%rbp)
movsd -0x30(%rbp), %xmm2
movapd %xmm1, -0x80(%rbp)
movapd %xmm0, -0x90(%rbp)
xorl %r13d, %r13d
movsd 0x4e6a(%rip), %xmm3     # 0x6a8e8
movsd -0x58(%rbp,%r13,8), %xmm4
incq %r13
xorl %eax, %eax
movsd -0xc0(%rbp,%rax,8), %xmm0
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd (%rbx,%rax,8), %xmm1
mulsd %xmm4, %xmm0
divsd %xmm3, %xmm0
addsd -0x90(%rbp,%rax,8), %xmm0
movsd %xmm1, -0xf0(%rbp,%rax,8)
movsd %xmm0, -0x90(%rbp,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x65a8a
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movsd %xmm4, -0x30(%rbp)
callq 0x65e74
movsd 0x4e01(%rip), %xmm3     # 0x6a8e8
movsd -0x30(%rbp), %xmm2
cmpq $0x3, %r13
jne 0x65a7e
xorl %eax, %eax
movsd 0x4f3c(%rip), %xmm0     # 0x6aa38
movsd -0x38(%rbp), %xmm2
movsd -0xc0(%rbp,%rax,8), %xmm1
mulsd %xmm2, %xmm1
divsd %xmm0, %xmm1
addsd -0x90(%rbp,%rax,8), %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x65b01
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsfright(double*, double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsfright(double* x, double* acc,GLSEPH& eph){
	const double c20 = -1.08262575e-3;
	const double GMEARTH = 3.986004418e5;
	const double EROT = 7.292115e-5;
	const double ER = 6.378136e3;
	int i;
	double factor1, factor2, r, vec1[3], vec2[3];
	r = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
	factor1 = -GMEARTH / pow(r, 3);
	factor2 = 1.5 * GMEARTH * c20 * ER * ER / pow(r, 5);
	vec1[0] = EROT * EROT * x[0] + 2.0 * EROT * x[4];
	vec1[1] = EROT * EROT * x[1] - 2.0 * EROT * x[3];
	vec1[2] = 0.0;
	vec2[0] = x[0] * (1.0 - 5.0 * pow((x[2] / r), 2));
	vec2[1] = x[1] * (1.0 - 5.0 * pow((x[2] / r), 2));
	vec2[2] = x[2] * (3.0 - 5.0 * pow((x[2] / r), 2));
	for (i = 0; i < 3; i++) {
		acc[i] = x[i + 3];
		acc[i + 3] = eph.acc[i] + vec1[i] + factor2 * vec2[i] + factor1 * x[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rsi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x4a28(%rip), %xmm1     # 0x6a8e8
callq 0x8b20
movsd 0x134cb(%rip), %xmm1    # 0x79398
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x58ea(%rip), %xmm1     # 0x6b7c8
movsd -0x20(%rbp), %xmm0
callq 0x8b20
movsd 0x134b0(%rip), %xmm1    # 0x793a0
divsd %xmm0, %xmm1
movsd (%r15), %xmm0
movsd 0x20(%r15), %xmm2
mulsd 0x134a1(%rip), %xmm2    # 0x793a8
movsd 0x134a1(%rip), %xmm3    # 0x793b0
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, -0x60(%rbp)
movsd 0x8(%r15), %xmm2
movsd 0x18(%r15), %xmm4
mulsd 0x13484(%rip), %xmm4    # 0x793b8
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movsd 0x10(%r15), %xmm3
movapd %xmm3, %xmm4
divsd -0x20(%rbp), %xmm4
mulsd %xmm4, %xmm4
mulsd 0x1345c(%rip), %xmm4    # 0x793c0
movsd 0x39b4(%rip), %xmm5     # 0x69920
addsd %xmm4, %xmm5
mulsd %xmm5, %xmm0
movsd %xmm0, -0x40(%rbp)
mulsd %xmm2, %xmm5
movsd %xmm5, -0x38(%rbp)
addsd 0x495e(%rip), %xmm4     # 0x6a8e8
mulsd %xmm3, %xmm4
movsd -0x28(%rbp), %xmm3
movsd %xmm4, -0x30(%rbp)
xorl %eax, %eax
movsd 0x18(%r15,%rax), %xmm0
movsd %xmm0, (%r14,%rax)
movsd 0x60(%rbx,%rax), %xmm0
addsd -0x60(%rbp,%rax), %xmm0
movsd -0x40(%rbp,%rax), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd (%r15,%rax), %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x18(%r14,%rax)
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x65f9a
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::RnxEphFileAdapter()
RnxEphFileAdapter::RnxEphFileAdapter() {
	memset(neph, 0, sizeof(int) * MAXSYS);
	mjd0 = mjd1 = leap = 0;
	sod0 = sod1 = ver = 0.0;
	memset(ionc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(ion, 0, sizeof(double) * MAXSYS * 2 * 4);
	memset(timc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(tim, 0, sizeof(double) * MAXSYS * 2 * 4);
	isOpen = 0;
	orbType = ORB_BRD;
	clkType = CLK_BRD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
movl $0x2ac, %edx            # imm = 0x2AC
xorl %esi, %esi
callq 0x8390
movb $0x0, 0x2c4(%rbx)
movabsq $0x4008cccccccccccd, %rax # imm = 0x4008CCCCCCCCCCCD
movq %rax, 0x2c8(%rbx)
movl $0x6f8, %eax            # imm = 0x6F8
leaq (%rbx,%rax), %rcx
movq %rcx, 0x8(%rbx,%rax)
movq %rcx, (%rbx,%rax)
movq $0x0, 0x10(%rbx,%rax)
addq $0x18, %rax
cmpq $0x7a0, %rax            # imm = 0x7A0
jne 0x66269
leaq 0x7a0(%rbx), %rax
movq %rax, 0x7a8(%rbx)
movq %rax, 0x7a0(%rbx)
movq $0x0, 0x7b0(%rbx)
leaq 0x278a6(%rip), %rax     # 0x8db58
movq %rax, (%rbx)
leaq 0x27934(%rip), %rax     # 0x8dbf0
movq %rax, 0x2b8(%rbx)
leaq 0x27956(%rip), %rax     # 0x8dc20
movq %rax, 0x6d0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x6d8(%rbx)
movups %xmm0, 0x6e4(%rbx)
leaq 0xdd0(%rbx), %r14
leaq 0x7b8(%rbx), %rdi
movl $0x1f8, %edx            # imm = 0x1F8
xorl %esi, %esi
callq 0x8390
xorps %xmm0, %xmm0
movups %xmm0, 0xdb0(%rbx)
movups %xmm0, 0xdbc(%rbx)
movl $0x204, %edx            # imm = 0x204
movq %r14, %rdi
xorl %esi, %esi
callq 0x8390
movl $0x3, 0x2c0(%rbx)
movl $0x6, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_closeRnxEph()
void RnxEphFileAdapter::v_closeRnxEph() {
	int isys;
	for (isys = 0; isys < MAXSYS; isys++) {
		this->gnssEph[isys].clear();
	}
	this->glsEph.clear();
	memset(neph, 0, sizeof(int) * MAXSYS);
	this->isOpen = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6f8(%rdi), %r14
xorl %r15d, %r15d
leaq (%r15,%r15,2), %rax
leaq (%r14,%rax,8), %r12
movq (%r12), %rdi
cmpq %r12, %rdi
je 0x67844
movq (%rdi), %r13
callq 0x85d0
movq %r13, %rdi
cmpq %r12, %r13
jne 0x67834
movq %r12, 0x8(%r12)
movq %r12, (%r12)
movq $0x0, 0x10(%r12)
incq %r15
cmpq $0x7, %r15
jne 0x67823
leaq 0x7a0(%rbx), %r14
movq 0x7a0(%rbx), %rdi
cmpq %r14, %rdi
je 0x67882
movq (%rdi), %r15
callq 0x85d0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x67872
movq %r14, 0x7a8(%rbx)
movq %r14, 0x7a0(%rbx)
movq $0x0, 0x7b0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x6d8(%rbx)
movups %xmm0, 0x6e4(%rbx)
movl $0x0, 0xdc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk) {
	// using rinex navigation file to acquire satellite clock
	int wk, iode = -1;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x44(%rbp), %r12
leaq -0x50(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1cf30
movq $0x0, (%rbx)
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x6795f
cmpl $0x43, %eax
jne 0x6792a
addsd 0xd26e(%rip), %xmm0     # 0x74b98
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq -0x38(%rbp), %r12
leaq 0x11b2c(%rip), %rsi     # 0x79470
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r10
pushq %r11
pushq %r12
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x67988
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x11aff(%rip), %rsi     # 0x79470
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r10
pushq %r11
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk, int* iode) {
	int wk;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x44(%rbp), %r13
leaq -0x50(%rbp), %rbx
movl %edx, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1cf30
movq $0x0, (%r14)
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x67a2a
cmpl $0x43, %eax
jne 0x679f7
addsd 0xd1a1(%rip), %xmm0     # 0x74b98
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x40(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x11a62(%rip), %rsi     # 0x79470
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x67a51
movq (%r12), %rax
leaq -0x38(%rbp), %r10
leaq 0x11a37(%rip), %rsi     # 0x79470
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat) {
	// using rinex navigation file to acquire orbit
	int wk, iode = -1;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x4c(%rbp), %r12
leaq -0x58(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1cf30
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x67af3
cmpl $0x43, %eax
jne 0x67abd
addsd 0xd0db(%rip), %xmm0     # 0x74b98
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x48(%rbp), %r11
leaq -0x40(%rbp), %r12
leaq 0x11a11(%rip), %rsi     # 0x794e8
leaq -0x38(%rbp), %r9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
pushq %r10
pushq %r11
pushq %r12
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x67b1d
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x119e3(%rip), %rsi     # 0x794e8
leaq -0x38(%rbp), %r9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
pushq %r10
pushq %r11
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat, int* iode) {
	// using rinex navigation file to acquire orbit
	// using rinex navigation file to acquire orbit
	int wk;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x4c(%rbp), %r13
leaq -0x58(%rbp), %rbx
movl %edx, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1cf30
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x67bca
cmpl $0x43, %eax
jne 0x67b96
addsd 0xd002(%rip), %xmm0     # 0x74b98
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x48(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x1193b(%rip), %rsi     # 0x794e8
leaq -0x38(%rbp), %r9
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %r8
pushq -0x30(%rbp)
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x67bf2
movq (%r12), %rax
leaq -0x40(%rbp), %r10
leaq 0x1190f(%rip), %rsi     # 0x794e8
leaq -0x38(%rbp), %r9
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %r8
pushq -0x30(%rbp)
pushq %r10
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::m_getCurrentEph_G(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
list<GPSEPH> RnxEphFileAdapter::m_getCurrentEph_G(string cprn, int mjd, double sod) {
	int isys,wk;
	double dt,sow,dtmin = 2.0;
	list<GPSEPH> list_out;
	list<GPSEPH>::iterator gpsItr;
	mjd2wksow(mjd, sod, &wk, &sow);
	isys = index_string(SYS, cprn[0]);
	for (gpsItr = this->gnssEph[isys].begin(); gpsItr != this->gnssEph[isys].end(); ++gpsItr) {
		if (strstr((*gpsItr).cprn, cprn.c_str())) {
			dt = (wk - (*gpsItr).week) * 168.0 + (sow - (*gpsItr).toe) / 3600.0;
			if (fabs(dt) < dtmin) {
				list_out.push_back(*gpsItr);
			}
		}
	}
	return list_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movl %ecx, %edi
callq 0x1cf30
movq (%r14), %rax
movsbl (%rax), %esi
leaq 0x11b9c(%rip), %rdi     # 0x797f6
callq 0x1d54b
cltq
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %r13
addq $0x6f8, %r13            # imm = 0x6F8
movq (%r13), %rbx
cmpq %r13, %rbx
je 0x67d11
leaq 0x10(%rbx), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x8160
testq %rax, %rax
je 0x67d09
xorps %xmm0, %xmm0
cvtsi2sdl -0x34(%rbp), %xmm0
subsd 0xc8(%rbx), %xmm0
movsd -0x40(%rbp), %xmm1
subsd 0x78(%rbx), %xmm1
divsd 0x2c0d(%rip), %xmm1     # 0x6a8c0
mulsd 0x116a5(%rip), %xmm0    # 0x79360
addsd %xmm1, %xmm0
andpd 0x1c69(%rip), %xmm0     # 0x69930
movsd 0x40e1(%rip), %xmm1     # 0x6bdb0
ucomisd %xmm0, %xmm1
jbe 0x67d09
movl $0x100, %edi            # imm = 0x100
callq 0x8640
movq %rax, %r12
movq %rax, %rdi
addq $0x10, %rdi
movl $0xf0, %edx
movq %r15, %rsi
callq 0x84f0
movq %r12, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x80c0
incq 0x10(%r15)
movq (%rbx), %rbx
jmp 0x67c74
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67d26
movq %rax, %r14
movq -0x30(%rbp), %r15
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x67d45
movq (%rdi), %rbx
callq 0x85d0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x67d35
movq %r14, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::m_getCurrentEph_R(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
list<GLSEPH> RnxEphFileAdapter::m_getCurrentEph_R(string cprn, int mjd, double sod) {
	double dt,dtmin = 1.0;
	list<GLSEPH> list_out;
	list<GLSEPH>::iterator glsItr;
	for (glsItr = this->glsEph.begin(); glsItr != this->glsEph.end(); ++glsItr) {
		if (strstr((*glsItr).cprn, cprn.c_str())) {
			dt = (mjd - (*glsItr).mjd) * 24.0 + (sod - (*glsItr).sod) / 3600.0;
			if (fabs(dt) < dtmin) {
				list_out.push_back(*glsItr);
			}
		}
	}
	return list_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x40(%rbp)
movl %ecx, -0x34(%rbp)
movq %rsi, %r12
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x7a0(%rsi), %rbx
addq $0x7a0, %r12            # imm = 0x7A0
cmpq %r12, %rbx
je 0x67e2c
movq %rdx, %r15
leaq 0x10(%rbx), %r13
movq (%r15), %rsi
movq %r13, %rdi
callq 0x8160
testq %rax, %rax
je 0x67e20
movl -0x34(%rbp), %eax
subl 0x14(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd -0x40(%rbp), %xmm1
subsd 0x20(%rbx), %xmm1
divsd 0x2af6(%rip), %xmm1     # 0x6a8c0
mulsd 0xcf56(%rip), %xmm0     # 0x74d28
addsd %xmm1, %xmm0
andpd 0x1b52(%rip), %xmm0     # 0x69930
movsd 0x1b3a(%rip), %xmm1     # 0x69920
ucomisd %xmm0, %xmm1
jbe 0x67e20
movl $0xa0, %edi
callq 0x8640
movq %rax, %r14
movq %rax, %rdi
addq $0x10, %rdi
movl $0x90, %edx
movq %r13, %rsi
callq 0x84f0
movq %r14, %rdi
movq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x80c0
incq 0x10(%r14)
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x67d97
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %r15
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x67e5e
movq (%rdi), %rbx
callq 0x85d0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x67e4e
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::chk_num(int, int, int)
int Sudoku::chk_num(int temp_num, int t_row, int t_col)
{
	if (temp_num > 9 || temp_num < 1)
	{
		return -1;
	}
	int i = 0, j = 0;
	
	for (j = 0; j < 9; j++)
	{
		if (temp_num == board[t_row][j].get_Int())
		{
			return -1;
		}
	}
	
	for (i = 0; i < 9; i++)
	{
		if (temp_num == board[i][t_col].get_Int())
		{
			return -1;
		}
	}

	i = t_row - (t_row%3);
	j = t_col - (t_col%3);
	int row_lim = i+3;
	int col_lim = j+3;

	for (i = t_row - (t_row%3); i < row_lim; i++)
	{
		for (j = t_col - (t_col%3); j < col_lim; j++)
		{
			if (temp_num == board[i][j].get_Int())
			{
				return -1;
			}
		}
	}
	return 0;
}

// Assembly:
leal -0xa(%rsi), %eax
cmpl $-0x9, %eax
jae 0x278a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movslq %edx, %rax
leaq (%rax,%rax,8), %rdx
leaq (%rdi,%rdx,8), %r8
xorl %r9d, %r9d
cmpl %esi, (%r8,%r9,8)
je 0x2784
incq %r9
cmpq $0x9, %r9
jne 0x2798
movslq %ecx, %r9
leaq (%rdi,%r9,8), %rcx
movq $-0x288, %r8            # imm = 0xFD78
cmpl %esi, 0x288(%rcx,%r8)
je 0x2784
addq $0x48, %r8
jne 0x27b5
pushq %rbx
imulq $0x55555556, %rax, %r10 # imm = 0x55555556
movq %r10, %rcx
shrq $0x3f, %rcx
shrq $0x20, %r10
addl %ecx, %r10d
leal (%r10,%r10,2), %ecx
subl %ecx, %eax
imulq $0x55555556, %r9, %r11  # imm = 0x55555556
movq %r11, %r8
shrq $0x3f, %r8
shrq $0x20, %r11
addl %r8d, %r11d
leal (%r11,%r11,2), %r8d
movl %r9d, %ebx
subl %r8d, %ebx
movslq %ecx, %r8
leal (%r11,%r11,2), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
leal 0x2(%r10,%r10,2), %r10d
movslq %r10d, %r10
movslq %ebx, %rbx
movq %rbx, %r11
notq %r11
addq %r9, %r11
shlq $0x3, %r9
leaq (%r9,%rdx,8), %rdx
shlq $0x3, %rbx
subq %rbx, %rdx
cltq
shlq $0x3, %rax
leaq (%rax,%rax,8), %rax
subq %rax, %rdx
addq %rdx, %rdi
movq %rdi, %rax
movq %r11, %rdx
cmpl %esi, (%rax)
je 0x286a
incq %rdx
addq $0x8, %rax
cmpq %rcx, %rdx
jl 0x2846
leaq 0x1(%r8), %rdx
addq $0x48, %rdi
xorl %eax, %eax
cmpq %r10, %r8
movq %rdx, %r8
jl 0x2840
jmp 0x286f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: user_gm::Player::timer(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void Player::timer(std::chrono::steady_clock::time_point start)
{
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
    std::chrono::duration<double,std::milli> t_diff = end-start;
    time_diff = t_diff.count() / 1000;
    int minute = 15 - (time_diff / 60);
    int seconds = 60 - ((int)time_diff % 60);   
    cout << "\t\t\t\t\t\t\t" << "Time left  " << minute << ":" << seconds << "\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2150
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x17bf(%rip), %xmm0     # 0x4050
divsd 0x17bf(%rip), %xmm0     # 0x4058
movsd %xmm0, (%r14)
cvttsd2si %xmm0, %eax
divsd 0x17b6(%rip), %xmm0     # 0x4060
addsd 0x17b6(%rip), %xmm0     # 0x4068
cvttsd2si %xmm0, %ebp
cltq
imulq $-0x77777777, %rax, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ebx
subl %eax, %ebx
addl $0x3c, %ebx
movq 0x36ea(%rip), %r14      # 0x5fc8
leaq 0x1821(%rip), %rsi      # 0x4106
movl $0x7, %edx
movq %r14, %rdi
callq 0x2130
leaq 0x1815(%rip), %rsi      # 0x410e
movl $0xb, %edx
movq %r14, %rdi
callq 0x2130
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movq %rax, %r14
leaq 0x1800(%rip), %rsi      # 0x411a
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
movq %r14, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x1aee(%rip), %rsi      # 0x4426
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::print_board()
void Sudoku::print_board()
{
	for (int i = 0; i < 9; i++)
	{
		cout << "-------------------------------------" << "\n";
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				cout << "|" << "   "; 
				
				/*skips or jumps out of the condition if the row or column lies outside the range*/
				continue;
			}
			cout << "| " << board[i][j].get_Int() << " "; 
		}
		cout << "|" << "\n";
	}
	cout << "-------------------------------------" << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x30eb(%rip), %r14      # 0x5fc8
leaq 0x1542(%rip), %r13      # 0x4426
leaq 0x148b(%rip), %r15      # 0x4376
leaq 0x1482(%rip), %r12      # 0x4374
movl $0x25, %edx
movq %r14, %rdi
leaq 0x1449(%rip), %rsi      # 0x434a
callq 0x2130
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2130
xorl %r13d, %r13d
cmpl $-0x1, (%rbx,%r13,8)
je 0x2f49
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movl (%rbx,%r13,8), %esi
movq %r14, %rdi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
jmp 0x2f6c
movl $0x1, %edx
movq %r14, %rdi
leaq 0x1418(%rip), %rsi      # 0x4370
callq 0x2130
movl $0x3, %edx
movq %r14, %rdi
leaq 0x1406(%rip), %rsi      # 0x4372
callq 0x2130
incq %r13
cmpq $0x9, %r13
jne 0x2f19
movl $0x1, %edx
movq %r14, %rdi
leaq 0x13e7(%rip), %rsi      # 0x4370
callq 0x2130
movl $0x1, %edx
movq %r14, %rdi
leaq 0x1489(%rip), %r13      # 0x4426
movq %r13, %rsi
callq 0x2130
incq %rbp
addq $0x48, %rbx
cmpq $0x9, %rbp
jne 0x2ef2
movq 0x300b(%rip), %rbx      # 0x5fc8
leaq 0x1386(%rip), %rsi      # 0x434a
movl $0x25, %edx
movq %rbx, %rdi
callq 0x2130
leaq 0x144e(%rip), %rsi      # 0x4426
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::chk_win()
int Sudoku::chk_win()
{
	int err_chk = 0;

	for (int i = 0; i < 9; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				return 0;
			}
		}
	}
	
	#ifdef __linux__
        err_chk = system("clear");
    #elif defined(_WIN32)
        err_chk = system("cls");
    #endif

	if (err_chk != 0)
	{
		cerr << "Error! Unable to clear the screen." << endl;
	}

	cout << "\n\n\n\n\t\t\t\tYOU HAVE WON THE GAME! CONGRATULATIONS!" << endl;
	return 1;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $-0x1, (%rdi,%rcx,8)
je 0x30b4
incq %rcx
cmpq $0x9, %rcx
jne 0x2ff9
incq %rax
addq $0x48, %rdi
cmpq $0x9, %rax
jne 0x2ff7
leaq 0x1359(%rip), %rdi      # 0x4379
callq 0x20c0
testl %eax, %eax
je 0x306b
movq 0x2fc0(%rip), %rbx      # 0x5ff0
leaq 0x1348(%rip), %rsi      # 0x437f
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq 0x2f56(%rip), %rbx      # 0x5fc8
leaq 0x1329(%rip), %rsi      # 0x43a2
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movl $0x1, %eax
jmp 0x30b6
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: findEmptyPlace(s_brd::cell (*) [9], int&, int&)
bool findEmptyPlace(cell t_board[9][9],int &row, int &col)
{ 
	for (row = 0; row < 9; row++)
	{
		for (col = 0; col < 9; col++)
		{
			if (t_board[row][col].get_Int() == -1) 
			{
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rsi)
movl $0x0, (%rbx)
xorl %ecx, %ecx
movslq (%r14), %rax
movslq %ecx, %rcx
leaq (%rax,%rax,8), %rax
leaq (%r15,%rax,8), %rax
leaq (%rax,%rcx,8), %rdi
callq 0x2352
cmpl $-0x1, %eax
je 0x33b6
movl (%rbx), %edx
leal 0x1(%rdx), %ecx
movl %ecx, (%rbx)
cmpl $0x8, %edx
jl 0x3380
movl (%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
cmpl $0x8, %ecx
jl 0x3378
cmpl $-0x1, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: safetyInGrid(s_brd::cell (*) [9], int, int, int)
bool safetyInGrid(cell t_board[9][9], int temp_num, int t_row, int t_col)
{
	int i = 0, j = 0;
	
	for (j = 0; j < 9; j++)
	{
		if (temp_num == t_board[t_row][j].get_Int())
		{
			return false;
		}
	}
	
	for (i = 0; i < 9; i++)
	{
		if (temp_num == t_board[i][t_col].get_Int())
		{
			return false;
		}
	}

	i = t_row - (t_row%3);
	j = t_col - (t_col%3);
	int row_lim = i+3;
	int col_lim = j+3;

	for (i = t_row - (t_row%3); i < row_lim; i++)
	{
		for (j = t_col - (t_col%3); j < col_lim; j++)
		{
			if (temp_num == t_board[i][j].get_Int())
			{
				return false;
			}
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movslq %edx, %r15
leaq (%r15,%r15,8), %rax
movq %rax, 0x8(%rsp)
leaq (%rdi,%rax,8), %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
callq 0x2352
cmpl %ebx, %eax
je 0x34ec
addq $0x8, %r13
cmpq $0x48, %r13
jne 0x33ea
movslq %ebp, %r13
leaq (%r14,%r13,8), %r12
xorl %ebp, %ebp
leaq (%r12,%rbp), %rdi
callq 0x2352
cmpl %ebx, %eax
je 0x34ec
addq $0x48, %rbp
cmpq $0x288, %rbp            # imm = 0x288
jne 0x340e
imulq $0x55555556, %r15, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal (%rax,%rax,2), %ecx
subl %ecx, %r15d
imulq $0x55555556, %r13, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %esi
movl %r13d, %edi
subl %esi, %edi
movslq %ecx, %rsi
leal (%rdx,%rdx,2), %ecx
addl $0x2, %ecx
movslq %ecx, %rbp
leal 0x2(%rax,%rax,2), %eax
cltq
movq %rax, 0x10(%rsp)
movslq %edi, %rax
movq %rax, %r12
notq %r12
addq %r13, %r12
shlq $0x3, %r13
movq 0x8(%rsp), %rcx
leaq (,%rcx,8), %rcx
addq %r13, %rcx
shlq $0x3, %rax
subq %rax, %rcx
movslq %r15d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rax
subq %rax, %rcx
addq %rcx, %r14
movq %rsi, 0x8(%rsp)
movq %r14, %r15
movq %r12, %r13
movq %r15, %rdi
callq 0x2352
cmpl %ebx, %eax
je 0x34ec
incq %r13
addq $0x8, %r15
cmpq %rbp, %r13
jl 0x34bc
movq 0x8(%rsp), %rdx
leaq 0x1(%rdx), %rsi
addq $0x48, %r14
movb $0x1, %al
cmpq 0x10(%rsp), %rdx
jl 0x34b1
jmp 0x34ee
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::solveSudoku(s_brd::cell (*) [9])
bool Sudoku::solveSudoku(cell t_board[9][9])
{
	int row, col;
   
	/* If true all the cells are filled and the game is complete */
   	if (!findEmptyPlace(t_board,row,col))
	{
		return true;
   	}
  
	for (int num = 1; num <= 9; num++)
	{
		if (safetyInGrid(t_board, num, row, col))
		{
        
			this->board[row][col].set_Val(num,false);
         
			if (solveSudoku(t_board))	
        	{
           		return true;
        	}
         
        	this->board[row][col].set_Val(-1,true);
      	}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movq %r14, %r12
xorl %r13d, %r13d
movq %rbp, %rdi
callq 0x2352
cmpl $-0x1, %eax
je 0x3560
incq %r13
addq $0x8, %r12
addq $0x8, %rbp
cmpq $0x9, %r13
jne 0x3528
incq %r15
addq $0x48, %r14
movq 0x10(%rsp), %rbp
addq $0x48, %rbp
cmpq $0x9, %r15
jne 0x351d
movb $0x1, %al
jmp 0x35b2
xorl %ebp, %ebp
movq 0x8(%rsp), %r14
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x33c2
testb %al, %al
je 0x35aa
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x234c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34fe
testb %al, %al
jne 0x355c
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x234c
cmpl $0x9, %ebp
jne 0x3567
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::init_gridPos()
void Sudoku::init_gridPos()
{
	srand(time(0));
	for (int i = 0; i < 81; i++)
	{
		this->gridPos[i] = i;
	}
	std::random_shuffle (this->gridPos, (this->gridPos)+81, genRandNum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x20e0
movl %eax, %edi
callq 0x20f0
leaq 0x514(%rbx), %r14
movdqa 0xa15(%rip), %xmm0      # 0x4010
movdqa 0xa1d(%rip), %xmm1      # 0x4020
movdqa 0xee5(%rip), %xmm2      # 0x44f0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0xa28(%rip), %xmm4      # 0x4040
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %eax
testb $0x1, %al
je 0x3645
movl %r15d, 0x514(%rbx,%r15,4)
pextrw $0x4, %xmm5, %eax
testb $0x1, %al
je 0x365a
leal 0x1(%r15), %eax
movl %eax, 0x518(%rbx,%r15,4)
addq $0x2, %r15
paddq %xmm4, %xmm0
cmpq $0x52, %r15
jne 0x3618
addq $0x518, %rbx            # imm = 0x518
movl $0x2, %ebp
xorl %r15d, %r15d
leaq (%rbx,%r15), %r12
callq 0x2050
cltd
idivl %ebp
movslq %edx, %rax
leaq (%r14,%rax,4), %rax
cmpq %rax, %r12
je 0x369b
movl (%r12), %ecx
movl (%rax), %edx
movl %edx, (%r12)
movl %ecx, (%rax)
incl %ebp
addq $0x4, %r15
cmpq $0x140, %r15            # imm = 0x140
jne 0x3677
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::count_Sols(int&)
void Sudoku::count_Sols (int &num)
{
	int row, col;
	if (!findEmptyPlace(this->board, row, col))
	{
		num++;
		return;
	}
	std::default_random_engine defEngine(time(0));
	std::uniform_int_distribution<int> intDistro(1,9);
	int randNum = 0;

	for (int i = 0; i < 9 && num < 2; i++)
	{
		randNum = intDistro(defEngine);
		if (safetyInGrid(this->board,randNum,row,col))
		{
			this->board[row][col].set_Val(randNum,false);
			count_Sols(num);
		}

		this->board[row][col].set_Val(-1,true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq $0x0, 0x10(%rsp)
movq %rdi, %rbx
movq %rbx, %r12
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x2352
cmpl $-0x1, %eax
je 0x3719
incq %r13
addq $0x8, %r12
cmpq $0x9, %r13
jne 0x36dc
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x48, %rbx
movq %rcx, 0x10(%rsp)
cmpq $0x9, %rcx
jne 0x36d6
movq 0x8(%rsp), %rax
incl (%rax)
jmp 0x37e0
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x20e0
movq %rax, %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x18(%rsp)
movabsq $0x900000001, %rax      # imm = 0x900000001
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jg 0x37e0
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
leaq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x38b6
movl %eax, %r15d
movq %r14, %rdi
movl %eax, %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
callq 0x33c2
testb %al, %al
je 0x37bd
movq %r12, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x234c
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x36b4
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x234c
cmpl $0x7, %ebx
ja 0x37e0
incl %ebx
movq 0x8(%rsp), %rax
cmpl $0x2, (%rax)
jl 0x377a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::cell_remover()
void Sudoku::cell_remover()
{	
	this->init_gridPos();
	for (int i = 0; i < 81 - filled; i++)
	{
		int x = gridPos[i]/9;
		int y = gridPos[i]%9;
		int temp_num = this->board[x][y].get_Int();
		this->board[x][y].set_Val(-1,true);

		int numSols = 0;
		count_Sols(numSols);

		if (numSols != 1)
		{
			this->board[x][y].set_Val(temp_num,false);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x35d0
cmpl $0x50, 0x288(%rbx)
jg 0x38a8
xorl %r12d, %r12d
leaq 0xc(%rsp), %r14
movslq 0x514(%rbx,%r12,4), %rax
imulq $0x38e38e39, %rax, %rcx # imm = 0x38E38E39
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,8), %edx
subl %edx, %eax
movslq %ecx, %rcx
cltq
leaq (%rcx,%rcx,8), %rcx
leaq (%rbx,%rcx,8), %rcx
leaq (%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x2352
movl %eax, %ebp
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x234c
movl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36b4
cmpl $0x1, 0xc(%rsp)
je 0x388d
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x234c
incq %r12
movslq 0x288(%rbx), %rax
movl $0x51, %ecx
subq %rax, %rcx
cmpq %rcx, %r12
jl 0x3819
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ninjabear[P]dr-doom/src/cpu.cpp
// Function: consume_cpu()
void consume_cpu() {
    int max_cores = std::thread::hardware_concurrency();

    std::thread threads[max_cores];

    for (int i=0; i<max_cores; i++) {
        threads[i] = std::thread(consume_thread);
    }

    for (int i=0; i<max_cores; i++) { // this will never complete
        threads[i].join();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2250
movl %eax, %r13d
movq %rsp, %rbx
leaq 0xf(,%r13,8), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
testl %eax, %eax
je 0x3295
leaq (,%r13,8), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
testl %r13d, %r13d
jle 0x3287
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
leaq 0x80(%rip), %rsi        # 0x32ca
callq 0x32ca
cmpq $0x0, (%rbx,%r15,8)
jne 0x32c5
movq -0x30(%rbp), %rax
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x3240
testl %r13d, %r13d
jle 0x3282
movq %r13, %r12
movq %rbx, %r15
movq %r15, %rdi
callq 0x22f0
addq $0x8, %r15
decq %r12
jne 0x3271
testq %r13, %r13
je 0x3295
cmpq $0x0, -0x8(%rbx,%r14)
jne 0x32c5
addq $-0x8, %r14
jne 0x3287
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32a6
testq %r13, %r13
je 0x32bd
shlq $0x3, %r13
cmpq $0x0, -0x8(%rbx,%r13)
jne 0x32c5
addq $-0x8, %r13
jne 0x32af
movq %rax, %rdi
callq 0x2320
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O3/ninjabear[P]dr-doom/src/memory.cpp
// Function: mt_consume_memory()
void mt_consume_memory() {   
    int max_cores = std::thread::hardware_concurrency();

    std::thread threads[max_cores];

    for (int i=0; i<max_cores; i++) {
        threads[i] = std::thread(consume_memory);
    }

    for (int i=0; i<max_cores; i++) { 
        threads[i].join();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2250
movl %eax, %r13d
movq %rsp, %rbx
leaq 0xf(,%r13,8), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
testl %eax, %eax
je 0x3949
leaq (,%r13,8), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
testl %r13d, %r13d
jle 0x393b
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
leaq 0x80(%rip), %rsi        # 0x397e
callq 0x32ca
cmpq $0x0, (%rbx,%r15,8)
jne 0x3979
movq -0x30(%rbp), %rax
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x38f4
testl %r13d, %r13d
jle 0x3936
movq %r13, %r12
movq %rbx, %r15
movq %r15, %rdi
callq 0x22f0
addq $0x8, %r15
decq %r12
jne 0x3925
testq %r13, %r13
je 0x3949
cmpq $0x0, -0x8(%rbx,%r14)
jne 0x3979
addq $-0x8, %r14
jne 0x393b
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x395a
testq %r13, %r13
je 0x3971
shlq $0x3, %r13
cmpq $0x0, -0x8(%rbx,%r13)
jne 0x3979
addq $-0x8, %r13
jne 0x3963
movq %rax, %rdi
callq 0x2320
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/event.cpp
// Function: Events::Event::raise_event(Events::EventArgs*)
void Event::raise_event(EventArgs* args) {
		vector<unique_ptr<EventHandler>>::iterator func = this->_subscribed_handlers.begin();
		for (; func != this->_subscribed_handlers.end(); ++func) {
			if (*func != nullptr && (*func)->_id != 0) {
				(*func)->set_event_args(args);
				(*(*func))((*func)->get_event_args());
#if DEBUG_ENABLED
				std::cout << "Notifying event handler #: " << (*func)->_id << std::endl;
#endif
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rax
cmpq %rax, %r12
je 0x3698
movq %rsi, %rbx
movq %rdi, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x368f
cmpl $0x0, 0x28(%rdi)
je 0x368f
movq %rbx, %rsi
callq 0x3b96
movq (%r12), %r15
movq %r15, %rdi
callq 0x3ad6
movq %r15, %rdi
movq %rax, %rsi
callq 0x3aac
movq 0x8(%r14), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0x365d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/event.cpp
// Function: Events::Event::remove_handler(Events::EventHandler const&)
void Event::remove_handler(const EventHandler &handler) {
		vector<unique_ptr<EventHandler>>::iterator to_remove = this->_subscribed_handlers.begin();
		for (; to_remove != this->_subscribed_handlers.end(); ++to_remove) {
			if (*(*to_remove) == handler) {
#if DEBUG_ENABLED
				std::cout << "Removing event handler #: " << (*to_remove)->_id << std::endl;
#endif
				this->_subscribed_handlers.erase(to_remove);
				break;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x3774
movq %rsi, %r14
movq %rdi, %rbx
movq %r12, %r15
negq %r15
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3b78
testb %al, %al
jne 0x377d
addq $0x8, %r12
addq $-0x8, %r15
cmpq 0x8(%rbx), %r12
jne 0x3756
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
negq %r15
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x39f6
nop
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/event_handler.cpp
// Function: Events::EventHandler::operator=(Events::EventHandler const&)
void EventHandler::operator=(const EventHandler &callback_func) {
		if (this->_callback_func == nullptr) {
			this->_callback_func = callback_func;
			this->_id = ++EventHandler::_witness_counter;
		}
		else {
			// Throw an exception to complain!
#if DEBUG_ENABLED
			std::cerr << "You cannot assign the event handler function again." << std::endl;
#endif
			throw new EventHandlerException("You cannot assign the event handler function again.");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
jne 0x3b15
movq %rdi, %rbx
callq 0x3ba0
movl 0x4651(%rip), %eax      # 0x8150
incl %eax
movl %eax, 0x4649(%rip)      # 0x8150
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x20a0
movq %rax, %rbx
movl $0x10, %edi
callq 0x2190
movq %rax, %r14
leaq 0x1726(%rip), %rsi      # 0x525c
movq %rax, %rdi
callq 0x3f48
movq %r14, (%rbx)
leaq 0x41f8(%rip), %rsi      # 0x7d40
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2210
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x21a0
jmp 0x3b67
movq %rax, %r15
movq %rbx, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/event_args.cpp
// Function: Events::EventArgs::EventArgs()
EventArgs::EventArgs()
	{
		set_event_type(0);
		set_args(nullptr);

		// Assign timestamp automatically
		set_timestamp(format_timestamp());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r15
movq %r15, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movl $0x0, (%rdi)
movq %rax, 0x8(%rdi)
leaq -0x38(%rbp), %rdi
callq 0x3f7a
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x20c0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dff
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e2b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3e2b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3e3e
movq (%r15), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/event_args.cpp
// Function: Events::EventArgs::EventArgs(int, std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
EventArgs::EventArgs(int event_type, std::map<int, string>* args)
	{
		set_event_type(event_type);
		set_args(args);
		
		// Assign timestamp automatically
		set_timestamp(format_timestamp());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r15
movq %r15, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq -0x38(%rbp), %rdi
callq 0x3f7a
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x20c0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ebf
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eeb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3eeb
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3efe
movq (%r15), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2230