LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_openRnxEph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RnxEphFileAdapter::v_openRnxEph(string ephcmd) {
	int curmjd;
	this->isOpen = 1;
	Deploy dly = Deploy::s_getConfigures();
	int iyear, imon, iday, ih, imin;
	double dsec, cursod;
	curmjd = atoi(ephcmd.substr(0, index_string(ephcmd.c_str(), ':')).c_str());
	cursod = atof(ephcmd.substr(index_string(ephcmd.c_str(), ':') + 1).c_str());

	mjd0 = curmjd;
	sod0 = 0.0;
	mjd1 = curmjd + 1;
	sod1 = 0.0;
	mjd2date(curmjd, cursod, &iyear, &imon, &iday, &ih, &imin, &dsec);
	memset(curFile, 0, sizeof(char) * 1024);
	strcpy(curFile, dly.ephdir);
	Patterns::s_getInstance()->m_getPatternName(true, "", "", iyear, imon, iday,
			ih, curFile);

	if (curFile[strlen(curFile) - 1] == 'p') {
		this->m_readRnxnav('M');
	} else {
		this->m_readRnxnav('G');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2090, %rsp           # imm = 0x2090
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0xdc8(%rdi)
leaq -0x20a8(%rbp), %rdi
callq 0x25f42
movq (%r14), %rdi
pushq $0x3a
popq %rsi
callq 0x1a5f7
movslq %eax, %rcx
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x8650
leaq -0x60(%rbp), %r12
movq (%r12), %rdi
callq 0x8990
movl %eax, %r15d
movq %r12, %rdi
callq 0x82c0
movq (%r14), %rdi
pushq $0x3a
popq %rsi
callq 0x1a5f7
incl %eax
movslq %eax, %rdx
leaq -0x60(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x8650
leaq -0x60(%rbp), %r14
movq (%r14), %rdi
callq 0x87b0
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x82c0
movl %r15d, 0xdb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xdb8(%rbx)
movl %r15d, %eax
incl %eax
movl %eax, 0xdb4(%rbx)
subq $0x8, %rsp
leaq -0x68(%rbp), %rax
leaq -0x30(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x3c(%rbp), %r9
movl %r15d, %edi
movsd -0x38(%rbp), %xmm0
pushq %rax
callq 0x19e07
popq %rax
popq %rcx
leaq 0x9b0(%rbx), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x8390
leaq -0x1df8(%rbp), %rsi
movq %r14, %rdi
callq 0x85c0
callq 0x21c74
movl -0x30(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movl -0x28(%rbp), %r10d
movl -0x24(%rbp), %r11d
subq $0x8, %rsp
leaq 0x3da6(%rip), %rcx      # 0x605e5
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rcx, %rdx
pushq %r14
pushq %r11
pushq %r10
callq 0x1f05e
addq $0x20, %rsp
movq %r14, %rdi
callq 0x8290
cmpb $0x70, 0x9af(%rbx,%rax)
pushq $0x4d
popq %rax
pushq $0x47
popq %rsi
cmovel %eax, %esi
movq %rbx, %rdi
callq 0x5c8b0
leaq -0x20a8(%rbp), %rdi
callq 0x25efe
addq $0x2090, %rsp           # imm = 0x2090
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c898
jmp 0x5c898
movq %rax, %rbx
leaq -0x20a8(%rbp), %rdi
callq 0x25efe
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6f8(%rdi), %r14
xorl %r15d, %r15d
cmpq $0xa8, %r15
je 0x5d9cb
leaq (%r14,%r15), %rdi
callq 0x22e5c
addq $0x18, %r15
jmp 0x5d9b3
leaq 0x7a0(%rbx), %rdi
callq 0x22e3a
xorps %xmm0, %xmm0
movups %xmm0, 0x6e4(%rbx)
movups %xmm0, 0x6d8(%rbx)
andl $0x0, 0xdc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
orl $-0x1, -0x2c(%rbp)
leaq -0x44(%rbp), %r12
leaq -0x50(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1a0c4
andq $0x0, (%rbx)
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x5da8d
cmpl $0x43, %eax
jne 0x5da58
addsd 0xd140(%rip), %xmm0     # 0x6ab98
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq -0x38(%rbp), %r12
leaq 0x119ce(%rip), %rsi     # 0x6f440
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 0x5dab6
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x119a1(%rip), %rsi     # 0x6f440
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_O2/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 0x1a0c4
andq $0x0, (%r14)
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x5db55
cmpl $0x43, %eax
jne 0x5db22
addsd 0xd076(%rip), %xmm0     # 0x6ab98
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x40(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x11907(%rip), %rsi     # 0x6f440
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 0x5db7c
movq (%r12), %rax
leaq -0x38(%rbp), %r10
leaq 0x118dc(%rip), %rsi     # 0x6f440
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
orl $-0x1, -0x2c(%rbp)
leaq -0x4c(%rbp), %r12
leaq -0x58(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1a0c4
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x5dc1c
cmpl $0x43, %eax
jne 0x5dbe6
addsd 0xcfb2(%rip), %xmm0     # 0x6ab98
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x48(%rbp), %r11
leaq -0x40(%rbp), %r12
leaq 0x118b8(%rip), %rsi     # 0x6f4b8
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 0x5dc46
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x1188a(%rip), %rsi     # 0x6f4b8
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a0c4
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x5dcf4
cmpl $0x43, %eax
jne 0x5dcc0
addsd 0xced8(%rip), %xmm0     # 0x6ab98
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x48(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x117e1(%rip), %rsi     # 0x6f4b8
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 0x5dd1c
movq (%r12), %rax
leaq -0x40(%rbp), %r10
leaq 0x117b5(%rip), %rsi     # 0x6f4b8
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_O2/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, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %ecx, %edi
callq 0x1a0c4
movq (%r14), %rax
movsbl (%rax), %esi
leaq 0x11a46(%rip), %rdi     # 0x6f7c6
callq 0x1a5f7
cltq
imulq $0x18, %rax, %rax
leaq (%r15,%rax), %r12
addq $0x6f8, %r12            # imm = 0x6F8
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x5de06
leaq 0x10(%r13), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x8170
testq %rax, %rax
je 0x5dd99
cvtsi2sdl -0x2c(%rbp), %xmm0
subsd 0xc8(%r13), %xmm0
movsd -0x38(%rbp), %xmm1
subsd 0x78(%r13), %xmm1
divsd 0x2ad9(%rip), %xmm1     # 0x608b0
mulsd 0x11551(%rip), %xmm0    # 0x6f330
addsd %xmm1, %xmm0
andpd 0x1b45(%rip), %xmm0     # 0x5f930
movsd 0x3fbd(%rip), %xmm1     # 0x61db0
ucomisd %xmm0, %xmm1
jbe 0x5dd99
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27d30
jmp 0x5dd99
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5de1a
movq %rax, %r14
movq %rbx, %rdi
callq 0x23af6
movq %r14, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x38(%rbp)
movl %ecx, %r14d
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
movq %rdx, %r15
movq %rsi, %rbx
addq $0x7a0, %rbx            # imm = 0x7A0
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x5ded5
leaq 0x10(%r12), %r13
movq (%r15), %rsi
movq %r13, %rdi
callq 0x8170
testq %rax, %rax
je 0x5de67
movl %r14d, %eax
subl 0x14(%r12), %eax
cvtsi2sd %eax, %xmm0
movsd -0x38(%rbp), %xmm1
subsd 0x20(%r12), %xmm1
divsd 0x2a0b(%rip), %xmm1     # 0x608b0
mulsd 0xce7b(%rip), %xmm0     # 0x6ad28
addsd %xmm1, %xmm0
andpd 0x1a77(%rip), %xmm0     # 0x5f930
movsd 0x1a5f(%rip), %xmm1     # 0x5f920
ucomisd %xmm0, %xmm1
jbe 0x5de67
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x27dee
jmp 0x5de67
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), %rdi
callq 0x23ad2
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpl $-0x9, %eax
jb 0x1694
movslq %edx, %r8
imulq $0x48, %r8, %r11
leaq (%rdi,%r11), %rax
xorl %edx, %edx
cmpq $0x9, %rdx
je 0x15ee
leaq 0x1(%rdx), %r9
cmpl %esi, (%rax,%rdx,8)
movq %r9, %rdx
jne 0x15d7
jmp 0x1694
movslq %ecx, %r9
leaq (%rdi,%r9,8), %rax
xorl %ecx, %ecx
leaq 0x48(%rcx), %rdx
cmpq $0x2d0, %rdx            # imm = 0x2D0
je 0x1611
cmpl %esi, (%rax,%rcx)
movq %rdx, %rcx
jne 0x15f7
jmp 0x1694
pushq %rbp
pushq %r14
pushq %rbx
movl $0x3, %ebx
movl %r8d, %eax
cltd
idivl %ebx
movl %edx, %ecx
movl %r8d, %ebp
subl %edx, %ebp
movl %r9d, %eax
cltd
idivl %ebx
movl %r9d, %ebx
subl %edx, %ebx
addl $0x3, %ebp
movslq %ebx, %rax
addl $0x3, %ebx
movslq %ebx, %rbx
movslq %ecx, %r14
negl %ecx
movslq %ecx, %rcx
addq %r8, %rcx
movslq %ebp, %r8
leaq (%r11,%r9,8), %r9
movslq %edx, %rdx
shlq $0x3, %rdx
subq %rdx, %r9
imulq $0x48, %r14, %rdx
subq %rdx, %r9
addq %r9, %rdi
cmpq %r8, %rcx
jge 0x168d
movq %rdi, %rdx
movq %rax, %r9
cmpq %rbx, %r9
jge 0x1684
incq %r9
leaq 0x8(%rdx), %r11
cmpl %esi, (%rdx)
movq %r11, %rdx
jne 0x166f
jmp 0x1690
incq %rcx
addq $0x48, %rdi
jmp 0x1664
xorl %r10d, %r10d
popq %rbx
popq %r14
popq %rbp
movl %r10d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1110
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1951(%rip), %xmm0     # 0x3008
divsd 0x1951(%rip), %xmm0     # 0x3010
movsd %xmm0, (%r14)
cvttsd2si %xmm0, %eax
divsd 0x1948(%rip), %xmm0     # 0x3018
addsd 0x1948(%rip), %xmm0     # 0x3020
cvttsd2si %xmm0, %ebp
pushq $0x3c
popq %rbx
cltd
idivl %ebx
subl %edx, %ebx
movq 0x38dd(%rip), %rdi      # 0x4fc8
leaq 0x19cc(%rip), %rsi      # 0x30be
callq 0x10f0
leaq 0x19c8(%rip), %rsi      # 0x30c6
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x1160
leaq 0x19bb(%rip), %rsi      # 0x30d2
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
movl %ebx, %esi
callq 0x1160
leaq 0x1cae(%rip), %rsi      # 0x33de
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x340b(%rip), %r14      # 0x4fc8
leaq 0x181a(%rip), %r13      # 0x33de
leaq 0x1763(%rip), %r15      # 0x332e
leaq 0x175a(%rip), %r12      # 0x332c
movq %r14, %rdi
leaq 0x1726(%rip), %rsi      # 0x3302
callq 0x10f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x10f0
cmpq $0x9, %rbp
je 0x1c79
movq %rbp, (%rsp)
xorl %ebp, %ebp
leaq 0x1725(%rip), %r13      # 0x3328
cmpq $0x9, %rbp
je 0x1c4c
cmpl $-0x1, (%rbx,%rbp,8)
je 0x1c2d
movq %r14, %rdi
movq %r15, %rsi
callq 0x10f0
movl (%rbx,%rbp,8), %esi
movq %rax, %rdi
callq 0x1160
movq %rax, %rdi
movq %r12, %rsi
jmp 0x1c42
movq %r14, %rdi
movq %r13, %rsi
callq 0x10f0
movq %rax, %rdi
leaq 0x16e8(%rip), %rsi      # 0x332a
callq 0x10f0
incq %rbp
jmp 0x1c03
movq %r14, %rdi
movq %r13, %rsi
callq 0x10f0
movq %rax, %rdi
leaq 0x177d(%rip), %r13      # 0x33de
movq %r13, %rsi
callq 0x10f0
movq (%rsp), %rbp
incq %rbp
addq $0x48, %rbx
jmp 0x1bd2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
xorl %eax, %eax
cmpq $0x9, %rax
je 0x1cb2
xorl %ecx, %ecx
cmpq $0x9, %rcx
je 0x1ca5
cmpl $-0x1, (%rdi,%rcx,8)
leaq 0x1(%rcx), %rcx
jne 0x1c93
jmp 0x1cae
incq %rax
addq $0x48, %rdi
jmp 0x1c8b
xorl %eax, %eax
popq %rcx
retq
leaq 0x1678(%rip), %rdi      # 0x3331
callq 0x10b0
testl %eax, %eax
je 0x1cdd
movq 0x3327(%rip), %rdi      # 0x4ff0
leaq 0x1667(%rip), %rsi      # 0x3337
callq 0x10f0
movq %rax, %rdi
callq 0x1080
movq 0x32e4(%rip), %rdi      # 0x4fc8
leaq 0x166f(%rip), %rsi      # 0x335a
callq 0x10f0
movq %rax, %rdi
callq 0x1080
pushq $0x1
popq %rax
jmp 0x1cb0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movl %ebp, (%r14)
cmpl $0x8, %ebp
jg 0x2061
xorl %eax, %eax
movl %eax, (%rbx)
movslq (%r14), %rcx
cmpl $0x8, %eax
jg 0x205b
cltq
imulq $0x48, %rcx, %rcx
addq %r15, %rcx
leaq (%rcx,%rax,8), %rdi
callq 0x1302
cmpl $-0x1, %eax
je 0x2061
movl (%rbx), %eax
incl %eax
jmp 0x2034
incl %ecx
movl %ecx, %ebp
jmp 0x202a
cmpl $0x9, %ebp
setl %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x48, %r15, %rax
movq %rax, 0x8(%rsp)
leaq (%rdi,%rax), %r12
xorl %edi, %edi
leaq 0x8(%rdi), %r13
cmpq $0x50, %r13
je 0x20b4
addq %r12, %rdi
callq 0x1302
movq %r13, %rdi
cmpl %ebx, %eax
jne 0x2099
jmp 0x20d9
movslq %ebp, %r12
leaq (%r14,%r12,8), %r13
xorl %edi, %edi
leaq 0x48(%rdi), %rbp
cmpq $0x2d0, %rbp            # imm = 0x2D0
je 0x20ea
addq %r13, %rdi
callq 0x1302
movq %rbp, %rdi
cmpl %ebx, %eax
jne 0x20bd
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x3
popq %rsi
movl %r15d, %eax
cltd
idivl %esi
movl %edx, %ecx
movl %r15d, %edi
subl %edx, %edi
movl %r12d, %eax
cltd
idivl %esi
movl %r12d, %eax
subl %edx, %eax
addl $0x3, %edi
addl $0x3, %eax
movslq %eax, %rbp
movslq %ecx, %rax
negl %ecx
movslq %ecx, %rsi
addq %r15, %rsi
movslq %edi, %rdi
movq 0x8(%rsp), %rcx
leaq (%rcx,%r12,8), %rcx
movslq %edx, %r15
leaq (,%r15,8), %rdx
subq %rdx, %rcx
imulq $0x48, %rax, %rax
subq %rax, %rcx
addq %rcx, %r14
notq %r15
addq %r12, %r15
movq %rdi, 0x10(%rsp)
cmpq %rdi, %rsi
jge 0x2188
movq %rsi, 0x8(%rsp)
movq %r15, %r12
movq %r14, %rdi
incq %r12
cmpq %rbp, %r12
jge 0x2175
leaq 0x8(%rdi), %r13
callq 0x1302
movq %r13, %rdi
cmpl %ebx, %eax
jne 0x2158
jmp 0x20d9
movq 0x8(%rsp), %rsi
incq %rsi
addq $0x48, %r14
movq 0x10(%rsp), %rdi
jmp 0x2148
movb $0x1, %al
jmp 0x20db
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2018
movb $0x1, %r14b
testb %al, %al
je 0x2225
movslq 0xc(%rsp), %r15
movslq 0x8(%rsp), %r12
imulq $0x48, %r15, %rax
addq 0x10(%rsp), %rax
leaq (%rax,%r12,8), %r13
pushq $0x1
popq %rbp
cmpl $0xa, %ebp
setne %r14b
je 0x2225
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x2072
testb %al, %al
je 0x2221
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12fc
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x2190
testb %al, %al
jne 0x2225
movq %r13, %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
callq 0x12fc
incl %ebp
jmp 0x21d9
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x10d0
movl %eax, %edi
callq 0x10e0
leaq 0x514(%rbx), %rdi
cmpq $0x51, %r14
je 0x2274
movl %r14d, (%rdi,%r14,4)
incq %r14
jmp 0x2265
addq $0x658, %rbx            # imm = 0x658
leaq -0x4b(%rip), %rdx       # 0x2237
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1cfd
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2018
testb %al, %al
je 0x236a
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x10d0
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq 0x18(%rsp), %rax
movq %rdx, (%rax)
movabsq $0x900000001, %rax      # imm = 0x900000001
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movslq 0xc(%rsp), %rax
movslq 0x8(%rsp), %rbp
movq %rax, 0x10(%rsp)
imulq $0x48, %rax, %rax
addq %r14, %rax
leaq (%rax,%rbp,8), %r15
cmpl $0x8, %r13d
ja 0x236c
cmpl $0x2, (%rbx)
jge 0x236c
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x241a
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
callq 0x2072
testb %al, %al
je 0x2357
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x12fc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2292
movq %r15, %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
callq 0x12fc
incl %r13d
jmp 0x230d
incl (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2246
xorl %ebp, %ebp
pushq $0x1
popq %r14
leaq 0x4(%rsp), %r15
movslq 0x288(%rbx), %rax
pushq $0x51
popq %rcx
subq %rax, %rcx
cmpq %rcx, %rbp
jge 0x240b
movl 0x514(%rbx,%rbp,4), %eax
cltd
pushq $0x9
popq %rcx
idivl %ecx
cltq
movslq %edx, %rcx
imulq $0x48, %rax, %rax
addq %rbx, %rax
leaq (%rax,%rcx,8), %r12
movq %r12, %rdi
callq 0x1302
movl %eax, %r13d
movq %r12, %rdi
pushq $-0x1
popq %rsi
movl %r14d, %edx
callq 0x12fc
andl $0x0, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2292
cmpl $0x1, 0x4(%rsp)
je 0x2406
movq %r12, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x12fc
incq %rbp
jmp 0x239a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ninjabear[P]dr-doom/src/main.cpp
// Function: usage()
void usage() {
    cout << "dr-doom." << endl;
    cout << endl;
    cout << "Usage:" << endl;
    cout << "  " << "dr-doom memory-cannon" << endl;
    cout << "  " << "dr-doom fork-bomb" << endl;
    cout << "  " << "dr-doom halt-catch-fire" << endl;
    cout << "  " << "dr-doom too-many-file-handles" << endl;
    cout << "  " << "dr-doom thread-bomb" << endl;
    cout << "  " << "dr-doom -h | --help" << endl;
    cout << "  " << "dr-doom -v | --version" << endl << endl;
    cout << "Options:" << endl;
    cout << "  " << "-h --help" << "\t" << "Show this screen." << endl;
    cout << "  " << "-v --version" << "\t" << "Display the version of dr-doom." << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4a2c(%rip), %rbx      # 0x6fd0
leaq 0x1b7e(%rip), %rsi      # 0x4129
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
leaq 0x1a6d(%rip), %rsi      # 0x4037
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
leaq 0x1a5d(%rip), %r14      # 0x403e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a4e(%rip), %rsi      # 0x4041
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a42(%rip), %rsi      # 0x4057
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a32(%rip), %rsi      # 0x4069
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a28(%rip), %rsi      # 0x4081
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a24(%rip), %rsi      # 0x409f
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a16(%rip), %rsi      # 0x40b3
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1a08(%rip), %rsi      # 0x40c7
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
leaq 0x1a00(%rip), %rsi      # 0x40de
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x19e7(%rip), %rsi      # 0x40e7
movq %rax, %rdi
callq 0x21e0
leaq 0x19e2(%rip), %r15      # 0x40f1
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x19d2(%rip), %rsi      # 0x40f3
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x19c2(%rip), %rsi      # 0x4105
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x19b5(%rip), %rsi      # 0x4112
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/ninjabear[P]dr-doom/src/main.cpp
// Function: get_mode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Mode get_mode(string& str) {
    if (str == "-h" || str == "--help") {
        return help;
    }

    if (str == "-v" || str == "--version") {
        return version;
    }

    if (str == "memory-cannon") {
        return memory;
    }

    if (str == "fork-bomb") {
        return fork_proc;
    }

    if (str == "halt-catch-fire") {
        return cpu;
    }

    if (str == "too-many-file-handles") {
        return file_handles;
    }

    if (str == "thread-bomb") {
        return thread_b;
    }

    return unknown;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19b3(%rip), %rsi      # 0x4132
callq 0x2b8d
pushq $0x5
popq %rbp
testb %al, %al
jne 0x2828
leaq 0x1954(%rip), %rsi      # 0x40ea
movq %rbx, %rdi
callq 0x2b8d
testb %al, %al
jne 0x2828
leaq 0x1988(%rip), %rsi      # 0x4135
movq %rbx, %rdi
callq 0x2b8d
pushq $0x6
popq %rbp
testb %al, %al
jne 0x2828
leaq 0x1945(%rip), %rsi      # 0x4108
movq %rbx, %rdi
callq 0x2b8d
testb %al, %al
jne 0x2828
leaq 0x1873(%rip), %rsi      # 0x4049
movq %rbx, %rdi
callq 0x2b8d
xorl %ebp, %ebp
testb %al, %al
jne 0x2828
leaq 0x1874(%rip), %rsi      # 0x405f
movq %rbx, %rdi
callq 0x2b8d
testb %al, %al
je 0x27fb
pushq $0x1
jmp 0x2827
leaq 0x186f(%rip), %rsi      # 0x4071
movq %rbx, %rdi
callq 0x2b8d
testb %al, %al
je 0x2812
pushq $0x4
jmp 0x2827
leaq 0x1870(%rip), %rsi      # 0x4089
movq %rbx, %rdi
callq 0x2b8d
testb %al, %al
je 0x2831
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x186f(%rip), %rsi      # 0x40a7
movq %rbx, %rdi
callq 0x2b8d
xorb $0x1, %al
movzbl %al, %eax
leal (%rax,%rax,4), %ebp
addl $0x2, %ebp
jmp 0x2828
// File: /workspace/github_cpp_makefile_star2_O2/ninjabear[P]dr-doom/src/main.cpp
// Function: are_you_sure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool are_you_sure(const string& prompt) {
    cout << prompt << endl;
    cout << endl;
    cout << "Are you sure? [y/N]: ";

    char ret = 0;
    cin.get(ret);

    return ret == 'y' || ret == 'Y';
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
movq 0x4774(%rip), %rbx      # 0x6fd0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
leaq 0x18bd(%rip), %rsi      # 0x4138
movq %rbx, %rdi
callq 0x21e0
leaq 0xf(%rsp), %rbx
movb $0x0, (%rbx)
movq 0x474e(%rip), %rdi      # 0x6fe0
movq %rbx, %rsi
callq 0x2250
movb (%rbx), %al
andb $-0x21, %al
cmpb $0x59, %al
sete %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
callq 0x2240
movl %eax, %r13d
movq %rsp, %r12
leaq 0xf(,%r13,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r12
movq %r12, %rsp
testl %eax, %eax
je 0x2c74
leaq (,%r13,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20f0
xorl %r15d, %r15d
testl %r13d, %r13d
cmovgl %r13d, %r15d
leaq -0x38(%rbp), %r14
movq %r12, -0x30(%rbp)
movq %r15, %rbx
subq $0x1, %rbx
jb 0x2cb7
movq %r14, %rdi
leaq 0x92(%rip), %rsi        # 0x2d2b
callq 0x2d2c
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d92
movq %r14, %rdi
callq 0x2dac
addq $0x8, %r12
jmp 0x2c89
movq -0x30(%rbp), %r14
subq $0x1, %r15
jb 0x2ccf
movq %r14, %rdi
callq 0x22e0
addq $0x8, %r14
jmp 0x2cbb
testq %r13, %r13
movq -0x30(%rbp), %rbx
je 0x2cef
addq $-0x8, %rbx
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x2dac
addq $-0x8, %r13
jne 0x2ce0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d00
movq %rax, %r14
testq %r13, %r13
movq -0x30(%rbp), %rbx
je 0x2d23
addq $-0x8, %rbx
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x2dac
addq $-0x8, %r13
jne 0x2d14
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
callq 0x2240
movl %eax, %r13d
movq %rsp, %r12
leaq 0xf(,%r13,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r12
movq %r12, %rsp
testl %eax, %eax
je 0x321c
leaq (,%r13,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20f0
xorl %r15d, %r15d
testl %r13d, %r13d
cmovgl %r13d, %r15d
leaq -0x38(%rbp), %r14
movq %r12, -0x30(%rbp)
movq %r15, %rbx
subq $0x1, %rbx
jb 0x325f
movq %r14, %rdi
leaq 0x92(%rip), %rsi        # 0x32d3
callq 0x2d2c
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d92
movq %r14, %rdi
callq 0x2dac
addq $0x8, %r12
jmp 0x3231
movq -0x30(%rbp), %r14
subq $0x1, %r15
jb 0x3277
movq %r14, %rdi
callq 0x22e0
addq $0x8, %r14
jmp 0x3263
testq %r13, %r13
movq -0x30(%rbp), %rbx
je 0x3297
addq $-0x8, %rbx
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x2dac
addq $-0x8, %r13
jne 0x3288
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32a8
movq %rax, %r14
testq %r13, %r13
movq -0x30(%rbp), %rbx
je 0x32cb
addq $-0x8, %rbx
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x2dac
addq $-0x8, %r13
jne 0x32bc
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/test/test_redisprotocol.cc
// Function: main
int main(){
	net::protocol::RedisProtocol p;

	test(p, "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n");

	test(p, "*2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");

	test(p, "*92\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "$2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "*2\r\n*3\r\nGET\r\n$4\r\ncity\r\n");

#if 0
	using Status = net::protocol::RedisProtocol::Status;

	const char *data = "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n";

	for(int i = 0; i < 2500000; ++i){
		const auto &status = p(data);

		if (status == Status::BUFFER_NOT_READ)
			std::cout << "problem" << '\n';
	}
#endif
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x12f8
leaq 0xd7f(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x132d
leaq 0xd93(%rip), %rsi       # 0x2027
leaq 0x8(%rsp), %rdi
callq 0x132d
leaq 0xd9a(%rip), %rsi       # 0x203f
leaq 0x8(%rsp), %rdi
callq 0x132d
leaq 0xda2(%rip), %rsi       # 0x2058
leaq 0x8(%rsp), %rdi
callq 0x132d
leaq 0xda9(%rip), %rsi       # 0x2070
leaq 0x8(%rsp), %rdi
callq 0x132d
leaq 0x8(%rsp), %rdi
callq 0x14ea
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14ea
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/test/test_redisprotocol.cc
// Function: void test<net::protocol::RedisProtocol>(net::protocol::RedisProtocol&, char const*)
void test(PROTOCOL &p, const char *data){
	using Status = typename PROTOCOL::Status;

	const Status status = p(data);

	std::cout	<< "Result status: " << test_status(status) << '\n'
			<< '\n'
	;

	if (status == Status::OK)
		p.print();

	std::cout	<< "---(eof)---" << '\n'
			<< '\n'
	;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1508
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1588
movl %eax, %ebp
movq 0x2c81(%rip), %rdi      # 0x3fd8
leaq 0xd3a(%rip), %rsi       # 0x2098
callq 0x10a0
cmpl $0x1, %ebp
leaq 0xd4a(%rip), %rcx       # 0x20b7
leaq 0xd48(%rip), %rdx       # 0x20bc
cmoveq %rcx, %rdx
testl %ebp, %ebp
leaq 0xd33(%rip), %rsi       # 0x20b4
cmovneq %rdx, %rsi
movq %rax, %rdi
callq 0x10a0
pushq $0xa
popq %r14
movq %rax, %rdi
movl %r14d, %esi
callq 0x10d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x10d0
testl %ebp, %ebp
jne 0x13b3
movq %rbx, %rdi
callq 0x1544
movq 0x2c1e(%rip), %rdi      # 0x3fd8
leaq 0xce7(%rip), %rsi       # 0x20a8
callq 0x10a0
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x10d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x10d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/slafi[P]EventSystem/EventSystem/main.cpp
// Function: callback_1(Events::EventArgs*)
void callback_1(EventArgs* args) {
	cout << "Callback #1 is notified and will show everything..." << endl;

	cout << "Callback #1 =>" << "Event type #" << args->get_event_type() << " triggered on " << args->get_timestamp() << endl;

	map<int, string> _args = *args->get_args();

	cout << "Callback #1 =>" << "Event type id: " << args->get_event_type() << endl;
	for (std::map<int, string>::iterator it = _args.begin(); it != _args.end(); ++it)
	{
		std::cout << "Callback #1 =>" << "Index: " << it->first << ", property: " << it->second << '\n';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x47e5(%rip), %r14      # 0x6fd0
leaq 0x189d(%rip), %rsi      # 0x408f
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20a0
leaq 0x18ba(%rip), %rsi      # 0x40c3
movq %r14, %rdi
callq 0x2190
leaq 0x18ba(%rip), %rsi      # 0x40d2
movq %rax, %rdi
callq 0x2190
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ae2
movq %r14, %rdi
movl %eax, %esi
callq 0x2240
leaq 0x18a3(%rip), %rsi      # 0x40df
movq %rax, %rdi
callq 0x2190
movq %rax, %r14
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3af4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20a0
leaq -0x58(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x3aea
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x2dac
movq 0x4743(%rip), %rdi      # 0x6fd0
leaq 0x182f(%rip), %rsi      # 0x40c3
callq 0x2190
leaq 0x184e(%rip), %rsi      # 0x40ee
movq %rax, %rdi
callq 0x2190
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ae2
movq %r14, %rdi
movl %eax, %esi
callq 0x2240
movq %rax, %rdi
callq 0x20a0
leaq -0x50(%rbp), %r14
movq 0x10(%r14), %r12
leaq 0x182a(%rip), %r15      # 0x40fe
leaq 0x182b(%rip), %r13      # 0x4106
pushq $0xa
popq %rbx
cmpq %r14, %r12
je 0x293d
movq 0x46e6(%rip), %rdi      # 0x6fd0
leaq 0x17d2(%rip), %rsi      # 0x40c3
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x2240
movq %rax, %rdi
movq %r13, %rsi
callq 0x2190
leaq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21d0
movq %r12, %rdi
callq 0x20f0
movq %rax, %r12
jmp 0x28de
leaq -0x58(%rbp), %rdi
callq 0x2c54
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x2971
jmp 0x2965
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2c54
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
cmpq 0x8(%r14), %r12
je 0x3312
movq (%r12), %rdi
testq %rdi, %rdi
je 0x330c
cmpl $0x0, 0x28(%rdi)
je 0x330c
movq %rbx, %rsi
callq 0x3818
movq (%r12), %r15
movq %r15, %rdi
callq 0x375e
movq %r15, %rdi
movq %rax, %rsi
callq 0x3750
addq $0x8, %r12
jmp 0x32d8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x33b8
movq (%r14), %rdi
movq %r15, %rsi
callq 0x37fa
testb %al, %al
jne 0x33c3
addq $0x8, %r14
jmp 0x339d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3486
// File: /workspace/github_cpp_makefile_star2_O2/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 0x379d
movq %rdi, %rbx
callq 0x3848
movl 0x39d9(%rip), %eax      # 0x7160
incl %eax
movl %eax, 0x39d1(%rip)      # 0x7160
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20b0
movq %rax, %rbx
pushq $0x10
popq %rdi
callq 0x21a0
movq %rax, %r14
leaq 0xa86(%rip), %rsi       # 0x4240
movq %rax, %rdi
callq 0x3b10
movq %r14, (%rbx)
leaq 0x3574(%rip), %rsi      # 0x6d40
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2230
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x21b0
jmp 0x37e9
movq %rax, %r15
movq %rbx, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
andl $0x0, (%rdi)
leaq 0x10(%rdi), %rbx
andq $0x0, 0x8(%rdi)
leaq -0x30(%rbp), %rdi
callq 0x3b42
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x20d0
leaq -0x30(%rbp), %rdi
callq 0x2090
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2090
jmp 0x3a44
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2250