LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: index_string(char const*, char)
int index_string(const char* src, char key) {
	int len = strlen(src);
	int i;
	for (i = 0; i < len; i++) {
		if (src[i] == key)
			break;
	}
	if (i == len)
		return -1;
	else
		return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3150
testl %eax, %eax
jle 0xb40f
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb %bl, (%r14,%rcx)
je 0xb411
incq %rcx
cmpq %rcx, %rdx
jne 0xb3fd
movl %eax, %ecx
jmp 0xb411
xorl %ecx, %ecx
cmpl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: len_trim(char const*)
int len_trim(const char* pStr) {
	int length = strlen(pStr);
	int count = length;
	int i;
	for (i = length - 1; i >= 0; i--) {
		if (pStr[i] == '\0' || pStr[i] == '\n' || pStr[i] == '\r'
				|| pStr[i] == ' ')
			count--;
		else
			break;
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3150
testl %eax, %eax
jle 0xb461
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movabsq $0x100002401, %rcx      # imm = 0x100002401
movzbl -0x1(%rbx,%rax), %edx
cmpq $0x20, %rdx
ja 0xb461
btq %rdx, %rcx
jae 0xb461
decq %rax
leaq 0x1(%rax), %rdx
cmpq $0x1, %rdx
jg 0xb441
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: filleph(char*, double)
void filleph(char* line,double ver){
	int i,len,cpre = 4;
	char tmp[128];
	if(ver < 3.0)
		cpre = 3;
	len = len_trim(line);
	for(i = len;i < cpre + 19 * 4;i++){
		line[i] = ' ';
	}
	line[cpre + 19 * 4] = '\0';
	for (i = 0; i < 4; i++) {
		substringEx(tmp, line + cpre + 19 * i, 0, 19);
		if (len_trim(tmp) == 0) {
			line[cpre + 19 * i + 1] = '0';
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movsd 0x287d(%rip), %xmm1     # 0xdd98
xorl %r14d, %r14d
ucomisd %xmm0, %xmm1
movq %rdi, %rbx
setbe %r14b
leal 0x3(%r14), %r15d
callq 0xb420
addq $0x4f, %r14
cmpl %r14d, %eax
jge 0xb556
movslq %eax, %rdi
addq %rbx, %rdi
movl %r15d, %edx
subl %eax, %edx
addl $0x4b, %edx
incq %rdx
movl $0x20, %esi
callq 0x31b0
movb $0x0, (%rbx,%r14)
movl %r15d, %r14d
addq %rbx, %r14
xorl %r15d, %r15d
leaq -0xa0(%rbp), %rbx
leaq (%r14,%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x13, %ecx
callq 0xb5a8
movq %rbx, %rdi
callq 0xb420
testl %eax, %eax
jne 0xb590
movb $0x30, 0x1(%r14,%r15)
addq $0x13, %r15
cmpq $0x4c, %r15
jne 0xb56b
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: substringEx(char*, char const*, int, int)
char* substringEx(char* dest, const char* src, int start, int length) {
	int i, j = 0;
	int len = strlen(src);
	if (start < 0 || start >= len || start + length > len) {
		dest[0] = '\0';
		return NULL;
	}
	for (i = start; i < start + length; i++) {
		dest[j] = src[i];
		j++;
	}
	dest[j] = '\0';
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3150
testl %r15d, %r15d
setns %cl
cmpl %r15d, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb5e2
leal (%r12,%r15), %ecx
cmpl %eax, %ecx
jle 0xb5e9
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0xb611
testl %r12d, %r12d
jle 0xb60c
movl %r15d, %eax
addq %rax, %r14
xorl %edx, %edx
movb (%r14,%rdx), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
leal (%rax,%rdx), %esi
cmpl %esi, %ecx
jg 0xb5f6
movl %edx, %eax
jmp 0xb60e
xorl %eax, %eax
addq %rbx, %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: genAode(char, int, double, double, int, GPSEPH*)
int genAode(char csys,int mjd,double sod,double toe,int inade,GPSEPH* eph){
	int mjd_r,ret = -1;
	double sod_r;
	if(csys == 'G' || csys == 'J')
		ret = inade;
	else if(csys == 'R'){
		timinc(mjd,sod, 19.0 - 37,&mjd_r,&sod_r);
		//ret = NINT(sod / 900.0) + 1;
		//IGMAS:
		ret = NINT(fmod(sod_r + 10800.0, 86400.0) / 900.0);
	}
	else if(csys == 'E'){
		// ret = NINT(sod / 600.0) + 1;
		//IGMAS:
		ret = inade;
	}
	else if(csys == 'C'){
		// ret = NINT(sod / 1800.0) + 1;
		//IGMAS:
		//ret = NINT(fmod(toe, 86400.0) / 450.0);
//		ret = getbdsiode(*eph);
		ret = (int)eph->iodc;
	}
	return ret;
}

// Assembly:
movl %edx, %eax
leal -0x43(%rdi), %edx
cmpl $0x7, %edx
ja 0xb63b
leaq 0x2d0f(%rip), %rsi      # 0xe340
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
retq
cmpl $0x52, %edi
jne 0xb6c5
pushq %rbp
movq %rsp, %rbp
addsd 0x2c90(%rip), %xmm0     # 0xe2e0
movsd 0x19d8(%rip), %xmm1     # 0xd030
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movapd %xmm0, %xmm3
addsd %xmm1, %xmm3
xorpd %xmm2, %xmm2
cmpnlesd %xmm0, %xmm2
andpd %xmm2, %xmm3
andnpd %xmm0, %xmm2
orpd %xmm3, %xmm2
addsd 0x2c53(%rip), %xmm2     # 0xe2e8
movapd %xmm2, %xmm0
callq 0x33a0
divsd 0x19aa(%rip), %xmm0     # 0xd050
xorl %eax, %eax
ucomisd 0x1998(%rip), %xmm0     # 0xd048
seta %al
leaq 0x2c76(%rip), %rcx      # 0xe330
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
cvttsd2si 0x100(%rcx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: timinc(int, double, double, int*, double*)
void timinc(int jd, double sec, double delt, int* jd1, double* sec1) {
	*sec1 = sec + delt;
	int inc = (int) (*sec1 / 86400.0);
	*jd1 = jd + inc;
	*sec1 = *sec1 - inc * 86400.0;
	if (*sec1 >= 0)
		return;
	*jd1 = *jd1 - 1;
	*sec1 = *sec1 + 86400;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movsd 0x1948(%rip), %xmm1     # 0xd030
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addl %edi, %eax
movl %eax, (%rsi)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0xb726
decl %eax
movl %eax, (%rsi)
addsd 0x190e(%rip), %xmm0     # 0xd030
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: CRC24(long, unsigned char const*)
unsigned long CRC24(long size, const unsigned char *buf) {
	unsigned long crc = 0;
	int ii;
	while (size--) {
		crc ^= (*buf++) << (16);
		for (ii = 0; ii < 8; ii++) {
			crc <<= 1;
			if (crc & 0x1000000) {
				crc ^= 0x01864cfb;
			}
		}
	}
	return crc;
}

// Assembly:
testq %rdi, %rdi
je 0xbe8f
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
decq %rdi
movzbl (%rsi), %ecx
shll $0x10, %ecx
xorq %rcx, %rax
movl $0x8, %ecx
leaq (%rax,%rax), %rdx
movq %rdx, %r8
xorq $0x1864cfb, %r8         # imm = 0x1864CFB
btl $0x17, %eax
movq %r8, %rax
cmovaeq %rdx, %rax
decl %ecx
jne 0xbe68
incq %rsi
testq %rdi, %rdi
jne 0xbe57
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: brdtime(char*, int*, double*)
void brdtime(char* cprn,int *mjd,double *sod){
	switch (cprn[0]) {
	case 'C':
	case 'B':
		timinc(*mjd, *sod, 14.0, mjd, sod);
		break;
	case 'R':
		//timinc(*mjd, *sod, Taiutc::s_getInstance()->m_getTaiutc(*mjd) - 19.0, mjd, sod);
		break;
	}
}

// Assembly:
movb (%rdi), %al
andb $-0x2, %al
cmpb $0x42, %al
jne 0xbef5
pushq %rbp
movq %rsp, %rbp
movsd (%rdx), %xmm0
addsd 0x116e(%rip), %xmm0     # 0xd018
movsd 0x117e(%rip), %xmm1     # 0xd030
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addl (%rsi), %eax
movsd %xmm0, (%rdx)
movl %eax, (%rsi)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0xbef4
decl %eax
movl %eax, (%rsi)
addsd 0x1140(%rip), %xmm0     # 0xd030
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: mjd2date(int, double, int*, int*, int*, int*, int*, double*)
void mjd2date(int jd, double sod, int* iyear, int* imonth, int* iday, int* ih,
		int* imin, double* sec) {
	int doy = 0;
	mjd2doy(jd, iyear, &doy);
	yeardoy2monthday(*iyear, doy, imonth, iday);

	*ih =  static_cast<int>( sod / 3600.0);
	*imin = static_cast<int> ((sod - (*ih) * 3600.0) / 60.0);
	*sec = sod - (*ih) * 3600.0 - (*imin) * 60.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movsd %xmm0, -0x30(%rbp)
leaq -0x3c(%rbp), %r14
movl $0x0, (%r14)
movq %r14, %rdx
callq 0xac62
movl (%r13), %edi
movl (%r14), %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbfc4
movsd 0x10c7(%rip), %xmm0     # 0xd010
movsd -0x30(%rbp), %xmm3
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movl %eax, (%rbx)
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm2
movapd %xmm3, %xmm4
subsd %xmm1, %xmm2
movsd 0x108c(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
xorps %xmm3, %xmm3
cvtsi2sdl (%rbx), %xmm3
mulsd %xmm0, %xmm3
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm4, %xmm2
subsd %xmm3, %xmm2
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm2
movq 0x10(%rbp), %rax
movsd %xmm2, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: yeardoy2monthday(int, int, int*, int*)
void yeardoy2monthday(int iyear, int idoy, int* imonth, int* iday) {
	int days_in_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int id, i;
	if ((iyear % 4 == 0 && iyear % 100 != 0) || iyear % 400 == 0)
		days_in_month[1] = 29;
	id = idoy;
	for (i = 0; i < 12; i++) {
		id = id - days_in_month[i];
		if (id > 0)
			continue;
		*iday = id + days_in_month[i];
		*imonth = i + 1;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps 0x23e1(%rip), %xmm0     # 0xe3b0
movaps %xmm0, -0x10(%rbp)
movaps 0x23c6(%rip), %xmm0     # 0xe3a0
movaps %xmm0, -0x20(%rbp)
movaps 0x23ab(%rip), %xmm0     # 0xe390
movaps %xmm0, -0x30(%rbp)
testb $0x3, %dil
sete %al
imull $0xc28f5c29, %edi, %r8d # imm = 0xC28F5C29
addl $0x51eb850, %r8d        # imm = 0x51EB850
movl %r8d, %edi
rorl $0x2, %edi
cmpl $0x28f5c29, %edi        # imm = 0x28F5C29
setae %dil
rorl $0x4, %r8d
cmpl $0xa3d70b, %r8d         # imm = 0xA3D70B
jb 0xc020
andb %dil, %al
je 0xc027
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
movl %esi, %edi
subl -0x30(%rbp,%rax,4), %edi
jle 0xc03e
incq %rax
movl %edi, %esi
cmpq $0xc, %rax
jne 0xc02b
jmp 0xc044
movl %esi, (%rcx)
incl %eax
movl %eax, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: unit_vector(int, double*, double*, double*)
void unit_vector(int n, double* v, double* u, double* length) {

	int i;
	*length = 0.0;
	for (i = 0; i < n; i++) {
		*length = *length + v[i] * v[i];
	}
	(*length) = sqrt(*length);
	for (i = 0; i < n; i++)
		u[i] = v[i] / (*length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
movq $0x0, (%rcx)
movl %edi, %r13d
testl %edi, %edi
jle 0xc08e
movsd (%rbx), %xmm0
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %rax
cmpq %rax, %r13
jne 0xc074
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc0a2
sqrtsd %xmm0, %xmm0
jmp 0xc0a7
callq 0x3230
movsd %xmm0, (%rbx)
testl %r12d, %r12d
jle 0xc0ca
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0xc0b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]eph_converter/src/Com.cpp
// Function: cross(double*, double*, double*)
void cross(double* v1, double*v2, double* vout) {
	double tmp[3];
	tmp[0] = v1[1] * v2[2] - v1[2] * v2[1];
	tmp[1] = v1[2] * v2[0] - v1[0] * v2[2];
	tmp[2] = v1[0] * v2[1] - v1[1] * v2[0];

	vout[0] = tmp[0];
	vout[1] = tmp[1];
	vout[2] = tmp[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rsi), %xmm2
movsd 0x10(%rdi), %xmm3
movsd (%rsi), %xmm4
movsd 0x8(%rsi), %xmm5
movapd %xmm1, %xmm6
mulsd %xmm2, %xmm6
mulsd %xmm0, %xmm2
mulsd %xmm5, %xmm0
mulsd %xmm3, %xmm5
subsd %xmm5, %xmm6
mulsd %xmm4, %xmm3
subsd %xmm2, %xmm3
mulsd %xmm1, %xmm4
subsd %xmm4, %xmm0
movsd %xmm6, (%rdx)
movsd %xmm3, 0x8(%rdx)
movsd %xmm0, 0x10(%rdx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: parse_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> parse_line(const string& line) {
  istringstream iss(line);
  vector<string> items;
  string item;
  while (iss >> item) {
    items.push_back(item);
  }
  return items;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21b0
xorl %eax, %eax
movq %rax, 0x10(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x241c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2744
jmp 0x23f6
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2433
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
movq 0x5b8e(%rip), %rsi      # 0x7fc8
leaq 0x28(%rsp), %rdi
callq 0x2160
leaq 0xa0(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x247d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2782
movq 0x5b3c(%rip), %rsi      # 0x7fc8
leaq 0x28(%rsp), %rdi
callq 0x2160
leaq 0xa0(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::build_header(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
vector<Header> build_header(
      const vector<string>& items) {
    vector<Header> header(items.size() + 1);
    int size = items.size();
    for (int i = 0; i <= size; i++) {
      if (i == 0) {
        header[i] = { size, 1 };
      } else {
        header[i] = { i - 1, (i + 1) % (size + 1) };
      }
    }
    return header;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x5, %rsi
incq %rsi
leaq 0x7(%rsp), %rdx
callq 0x3014
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
testl %eax, %eax
js 0x2a6b
movl %eax, %ecx
leaq 0x1(%rcx), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
testq %r8, %r8
je 0x2a5a
leal 0x1(%r8), %r9d
cmpq %r8, %rcx
cmovel %edi, %r9d
leal -0x1(%r8), %r10d
movl %r10d, (%rsi,%r8,8)
movl %r9d, 0x4(%rsi,%r8,8)
jmp 0x2a63
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
incq %r8
cmpq %r8, %rdx
jne 0x2a3b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level].option = nodes[item].dlink;
    for (auto& option = solution[level].option; option != item; option = nodes[option].dlink) {
      try_option(option, solution[level]);
      if (active == 1) {
        int size = nodes[header[0].rlink].top;
        count += size;
        if (DEBUG) {
          hist[size]++;
        }
      } else {
        solve(level + 1);
      }
      rewind_option(option, solution[level]);
    }
    uncover(item);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x4(%rax)
je 0x3ab9
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3aca
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x3b0c
movslq %r14d, %rcx
leaq (%rcx,%rcx,2), %rdx
movslq %ebp, %rsi
movq 0x18(%rbx), %rdi
movq 0x38(%rbx), %rax
leaq (%rsi,%rsi,2), %r15
movl 0x8(%rdi,%rdx,4), %esi
movl %esi, (%rax,%r15,4)
cmpl %ecx, %esi
je 0x3aa6
leaq (%rax,%r15,4), %r12
incl %ebp
shlq $0x2, %r15
movq 0x38(%rbx), %rcx
addq %r15, %rcx
movq %rbx, %rdi
movq %rbx, %rdx
movq %rcx, %r8
callq 0x3c7e
cmpl $0x1, 0xa8(%rbx)
jne 0x3a6d
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x4(%rax), %rax
leaq (%rax,%rax,2), %rax
movslq (%rcx,%rax,4), %rax
addq %rax, 0xb0(%rbx)
jmp 0x3a77
movq %rbx, %rdi
movl %ebp, %esi
callq 0x39d8
movl (%r12), %esi
movq 0x38(%rbx), %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %rbx, %rcx
callq 0x3d40
movslq (%r12), %rax
movq 0x18(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,4), %esi
movl %esi, (%r12)
cmpl %r14d, %esi
jne 0x3a33
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3b74
incq 0xb0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::cover(int)
void cover(int i) {
    active--;
    for (auto p = nodes[i].dlink; p != i; p = nodes[p].dlink) {
      hide(p);
    }
    auto l = header[i].llink;
    auto r = header[i].rlink;
    header[l].rlink = r;
    header[r].llink = l;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl 0xa8(%rdi)
movslq %esi, %r15
movq 0x18(%rdi), %rax
leaq (%r15,%r15,2), %rcx
movl 0x8(%rax,%rcx,4), %r14d
cmpl %r15d, %r14d
je 0x3b56
movl %esi, %ebp
movq %rbx, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x3bce
movslq %r14d, %rax
movq 0x18(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,4), %r14d
cmpl %ebp, %r14d
jne 0x3b33
movq (%rbx), %rax
movslq (%rax,%r15,8), %rcx
movslq 0x4(%rax,%r15,8), %rdx
movl %edx, 0x4(%rax,%rcx,8)
movl %ecx, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::uncover(int)
void uncover(int i) {
    active++;
    auto l = header[i].llink;
    auto r = header[i].rlink;
    header[l].rlink = i;
    header[r].llink = i;
    for (auto p = nodes[i].ulink; p != i; p = nodes[p].ulink) {
      unhide(p);
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
incl 0xa8(%rdi)
movslq %esi, %rax
movq (%rdi), %rcx
movslq (%rcx,%rax,8), %rdx
movslq 0x4(%rcx,%rax,8), %rsi
movl %eax, 0x4(%rcx,%rdx,8)
movl %eax, (%rcx,%rsi,8)
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
movl 0x4(%rcx,%rdx,4), %ebp
cmpl %eax, %ebp
je 0x3bc9
movq %rdi, %r14
movq %r14, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3dc6
movslq %ebp, %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,2), %rax
movl 0x4(%rcx,%rax,4), %ebp
cmpl %ebx, %ebp
jne 0x3ba9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: void ExactCover::option_right_edges<ExactCover::unhide(int)::'lambda'(int), void ExactCover::option_right<ExactCover::unhide(int)::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int))::'lambda'(int), void ExactCover::option_right<ExactCover::unhide(int)::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int))::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int), void ExactCover::option_right<ExactCover::unhide(int)::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int))::'lambda'(int), void ExactCover::option_right<ExactCover::unhide(int)::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int))::'lambda'(int))
void option_right_edges(int option, T action, P action_right, Q action_left) {
    auto p = option + 1;
    if (nodes[option].top > 0) {
      do {
        action(p);
      } while (nodes[p++].top > 0);
      action_right(p - 1);
    } else {
      action_right(option);
    }

    for (p = option - 1; nodes[p].top > 0; p--) {
      action(p);
    }
    action_left(p + 1);
  }

// Assembly:
movslq %esi, %r8
movq 0x18(%rdi), %rax
leaq (%r8,%r8,2), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x3e28
movq 0x18(%rdx), %rcx
leal 0x1(%r8), %edi
shlq $0x2, %r8
leaq (%r8,%r8,2), %r8
movl 0xc(%rcx,%r8), %r9d
movl %r9d, %r10d
negl %r10d
cmovsl %r9d, %r10d
movslq 0x10(%rcx,%r8), %r9
leaq (%r9,%r9,2), %r9
movslq 0x14(%rcx,%r8), %r11
movl %edi, 0x8(%rcx,%r9,4)
leaq (%r11,%r11,2), %r9
leaq (%r10,%r10,2), %r10
movl %edi, 0x4(%rcx,%r9,4)
incl (%rcx,%r10,4)
incl %edi
cmpl $0x0, 0xc(%rax,%r8)
leaq 0xc(%r8), %r8
jg 0x3de7
decl %esi
movslq %esi, %rdi
leaq (%rdi,%rdi,2), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x3e7f
movq 0x18(%rdx), %rcx
shlq $0x2, %rdi
leaq (%rdi,%rdi,2), %rdx
movl (%rcx,%rdx), %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movslq 0x4(%rcx,%rdx), %rdi
leaq (%rdi,%rdi,2), %rdi
movslq 0x8(%rcx,%rdx), %r9
movl %esi, 0x8(%rcx,%rdi,4)
leaq (%r9,%r9,2), %rdi
leaq (%r8,%r8,2), %r8
movl %esi, 0x4(%rcx,%rdi,4)
incl (%rcx,%r8,4)
decl %esi
cmpl $0x0, -0xc(%rax,%rdx)
leaq -0xc(%rdx), %rdx
jg 0x3e43
retq
// File: /workspace/github_cpp_makefile_star2_O1/ricbit[P]dlx/cover_shortcut.cc
// Function: void ExactCover::option_left<ExactCover::rewind_option(int, Solution const&)::'lambda'(int)>(int, Solution const&, ExactCover::rewind_option(int, Solution const&)::'lambda'(int))
void option_left(int option, const Solution& sol, T action) {
    for (auto p = sol.left; p != option; p++) {
      action(p);
    }
    for (auto p = sol.right; p != option; p--) {
      action(p);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movslq 0x4(%rdx), %rax
cmpl %eax, %esi
je 0x3d89
movq %rax, %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %r15
movl %ebp, %r12d
subl %eax, %r12d
movq 0x18(%rbx), %rax
movl (%rax,%r15), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movq %rbx, %rdi
callq 0x3b74
addq $0xc, %r15
decl %r12d
jne 0x3d69
movslq 0x8(%r14), %rax
cmpl %eax, %ebp
je 0x3dbd
movq %rax, %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %r14
subl %eax, %ebp
movq 0x18(%rbx), %rax
movl (%rax,%r14), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movq %rbx, %rdi
callq 0x3b74
addq $-0xc, %r14
incl %ebp
jne 0x3d9e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/articlesearch.cpp
// Function: ArtikelNameSuche[abi:cxx11]()
std::string ArtikelNameSuche ()
{
  std::string ArtikelName;
	//cout<< "Bitte geben Sie den Namen des Produktes ein!" <<endl;
  std::cout << "Please enter the Article Name" << std::endl;
  std::cin >> ArtikelName;

	return ArtikelName;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x371c(%rip), %r14      # 0x5fc8
leaq 0x1843(%rip), %rsi      # 0x40f6
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x36ea(%rip), %rdi      # 0x5fc8
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x36e6(%rip), %rdi      # 0x5fd8
movq %rbx, %rsi
callq 0x21a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2919
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/filehandler.cpp
// Function: getFileName[abi:cxx11]()
std::string getFileName()
{
	std::string filename;
	std::cout << "Please enter in the name of the file you'd like to open: ";
	std::cin >> filename;
	return filename;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x354d(%rip), %rdi      # 0x5fc8
leaq 0x16db(%rip), %rsi      # 0x415d
movl $0x39, %edx
callq 0x2160
movq 0x3545(%rip), %rdi      # 0x5fd8
movq %rbx, %rsi
callq 0x21a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2aba
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/filehandler.cpp
// Function: open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::basic_fstream<char, std::char_traits<char>>&)
void open(std::string filepath, std::fstream& file)
{
	bool file_exists = checkFileExistence(filepath);
	if (!file_exists)
	{
		std::cout << "File " << filepath << " not found.\n";
		filepath = getFileName(); //Not found
		std::ofstream dummy(filepath.c_str());
		if (!dummy.is_open()) {
			std::cerr << "Could not create file.\n";
			return;
		}
		std::cout << "File created.\n";
	}
	else
	{
		file.open(filepath.c_str());
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2a18
testb %al, %al
je 0x2af5
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x18, %edx
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
jmp 0x2110
movq 0x34cc(%rip), %r14      # 0x5fc8
leaq 0x1694(%rip), %rsi      # 0x4197
movl $0x5, %edx
movq %r14, %rdi
callq 0x2160
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2160
leaq 0x1677(%rip), %rsi      # 0x419d
movl $0xc, %edx
movq %rax, %rdi
callq 0x2160
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a59
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2b65
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x2150
leaq 0x78(%rsp), %rdi
callq 0x2060
movq 0x3468(%rip), %rdi      # 0x5ff0
testb %al, %al
cmovneq 0x3436(%rip), %rdi      # 0x5fc8
leaq 0x1629(%rip), %rcx      # 0x41c2
leaq 0x160a(%rip), %rsi      # 0x41aa
cmovneq %rcx, %rsi
xorb $0x1, %al
movzbl %al, %eax
leaq (%rax,%rax,8), %rdx
addq $0xe, %rdx
callq 0x2160
movq 0x3403(%rip), %rax      # 0x5fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x20f0
leaq 0x100(%rsp), %rdi
callq 0x2080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/filehandler.cpp
// Function: writeLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::basic_fstream<char, std::char_traits<char>>&)
void writeLine(std::string line, std::fstream& file)
{
	/* Format der hineingeschriebenen Daten Nummer;Bezeichnung;Preis */
	if (file.is_open())
	{
		file << line << std::endl;
	}
	else
	{
		std::cout << "File must be open!" << std::endl;
	}

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rsi), %rdi
callq 0x2060
testb %al, %al
je 0x2c3a
addq $0x10, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
jmp 0x2c55
movq 0x3387(%rip), %rbx      # 0x5fc8
leaq 0x1589(%rip), %rsi      # 0x41d1
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/filehandler.cpp
// Function: getData(std::basic_fstream<char, std::char_traits<char>>&, TArticle*)
void getData(std::fstream& file, TArticle AlleArtikel[1000])
{
	if (!file.is_open())
	{
		std::cout << "File must be open!" << std::endl;
	}
	else 
	{
		char cText[256];
		char * pch;
		int i = 0;
		int n;
		while (!file.eof()){
			file.getline(cText, sizeof(cText));
			pch = strtok(cText, ";");
			n = 1;
			while (pch != NULL)
			{
				if (n == 1)
					AlleArtikel[i].id = atoi(pch);
				else if (n == 2)
					strcpy(AlleArtikel[i].name, pch);
				else if (n == 3)
					AlleArtikel[i].price = atof(pch);
				pch = strtok(NULL, ";");
				n++;
			}
			i++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, (%rsp)
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x2060
testb %al, %al
je 0x2dab
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rbx,%rdi)
jne 0x2d99
addq %rbx, %rdi
xorl %ebp, %ebp
leaq 0x1512(%rip), %r12      # 0x41e4
movq %rbx, 0x8(%rsp)
movl $0xa, %esi
callq 0x2130
movsbl %al, %ecx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x2250
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
testq %rax, %rax
je 0x2d7b
imulq $0x110, %rbp, %rcx      # imm = 0x110
movq (%rsp), %rdx
leaq (%rdx,%rcx), %r15
addq $0x108, %r15            # imm = 0x108
leaq (%rdx,%rcx), %rbx
leaq (%rdx,%rcx), %r13
addq $0x4, %r13
movl $0x1, %r14d
cmpl $0x3, %r14d
je 0x2d5c
cmpl $0x2, %r14d
je 0x2d4f
cmpl $0x1, %r14d
jne 0x2d69
movq %rax, %rdi
callq 0x21f0
movl %eax, (%rbx)
jmp 0x2d69
movq %r13, %rdi
movq %rax, %rsi
callq 0x2120
jmp 0x2d69
movq %rax, %rdi
callq 0x2190
movsd %xmm0, (%r15)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2200
incl %r14d
testq %rax, %rax
jne 0x2d31
incq %rbp
movq 0x8(%rsp), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x2, 0x20(%rbx,%rax)
je 0x2cd7
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3216(%rip), %rbx      # 0x5fc8
leaq 0x1418(%rip), %rsi      # 0x41d1
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/main.cpp
// Function: main
int main (void)
{
	TArticle AlleArtikel[1000];
	std::string db_path = "database.csv";
	bool exit = false;
	char input;
	std::fstream database;
	open(db_path, database);
	getData(database, AlleArtikel);
  std::cout << "Hey, I'm your crazy ERP-System, what do you want to do?\n";
	while(!exit)
	{
		menue(AlleArtikel);
		std::cout << "Do you want to exit the Tool(y)?" << "\n";
		std::cin >> input;
		if(input == 'y' || input == 'Y' || input == 'z' || input == 'Z')
		{
			exit = true;
		}
	}
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428e8, %rsp          # imm = 0x428E8
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x13c5(%rip), %rsi      # 0x41e6
leaq 0x13ca(%rip), %rdx      # 0x41f2
leaq 0x10(%rsp), %rdi
callq 0x2986
leaq 0x50(%rsp), %rdi
callq 0x2170
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x2fba
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2ac2
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e82
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x50(%rsp), %rdi
leaq 0x260(%rsp), %rsi
callq 0x2c88
movq 0x312d(%rip), %rdi      # 0x5fc8
leaq 0x1351(%rip), %rsi      # 0x41f3
movl $0x38, %edx
callq 0x2160
xorl %ebx, %ebx
movq 0x3113(%rip), %r14      # 0x5fc8
leaq 0x1370(%rip), %r15      # 0x422c
leaq 0x1458(%rip), %r12      # 0x431b
movq 0x310e(%rip), %r13      # 0x5fd8
leaq 0xf(%rsp), %rbp
leaq 0x260(%rsp), %rdi
callq 0x304c
movl $0x20, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2160
movq %r13, %rdi
movq %rbp, %rsi
callq 0x21b0
movzbl 0xf(%rsp), %eax
addl $-0x59, %eax
cmpl $0x21, %eax
ja 0x2f26
movabsq $0x300000003, %rcx      # imm = 0x300000003
btq %rax, %rcx
jae 0x2f26
movb $0x1, %bl
testb $0x1, %bl
je 0x2ecf
leaq 0x50(%rsp), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2f51
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
xorl %eax, %eax
addq $0x428e8, %rsp          # imm = 0x428E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2f8b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x2f8b
movq %rax, %rbx
jmp 0x2f95
jmp 0x2f88
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2fb1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/menue.cpp
// Function: menue(TArticle*)
int menue (TArticle AlleArtikel[])
{
	char choice;

  std::cout << " Please choose one of these menue points: " << std::endl;
  std::cout << " (1) teuersterArtikel " << std::endl;
  std::cout << " (2) guenstigsterArtikel " << std::endl;
  std::cout << " (3) anzahlArtikel " << std::endl;
  std::cout << " (4) ArtikelSuche " << std::endl;

  while (true)
  {
    std::cout << " Please enter your choice: ";
    std::cin >> choice;

    switch (choice) 
    {
      case '1': teuersterArtikel(AlleArtikel); break;
      case '2': guenstigsterArtikel(AlleArtikel); break;
      case '3': anzahlArtikel(AlleArtikel); break;
      case '4': ArtikelSuche(AlleArtikel); break;
      default: std::cout << "Please choose a valid entry!\n"; return 0; break;
    }

  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2f67(%rip), %r14      # 0x5fc8
leaq 0x11f8(%rip), %rsi      # 0x4260
movl $0x2a, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
leaq 0x11e8(%rip), %rsi      # 0x428b
movl $0x16, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
leaq 0x11c4(%rip), %rsi      # 0x42a2
movl $0x19, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
leaq 0x11a3(%rip), %rsi      # 0x42bc
movl $0x13, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
leaq 0x117c(%rip), %rsi      # 0x42d0
movl $0x12, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
leaq 0x1154(%rip), %r15      # 0x42e3
movq 0x2e42(%rip), %r12      # 0x5fd8
leaq 0x7(%rsp), %r13
leaq 0x10ae(%rip), %rbp      # 0x4250
movl $0x1b, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq %r12, %rdi
movq %r13, %rsi
callq 0x21b0
movzbl 0x7(%rsp), %eax
addl $-0x31, %eax
cmpl $0x3, %eax
ja 0x31fc
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x3228
jmp 0x31a2
movq %rbx, %rdi
callq 0x344a
jmp 0x31a2
movq %rbx, %rdi
callq 0x242c
jmp 0x31a2
movq %rbx, %rdi
callq 0x3339
jmp 0x31a2
movq 0x2dc5(%rip), %rdi      # 0x5fc8
leaq 0x10f5(%rip), %rsi      # 0x42ff
movl $0x1d, %edx
callq 0x2160
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/statistics.cpp
// Function: teuersterArtikel(TArticle*)
int teuersterArtikel(TArticle AlleArtikel[]) // Programm f�r die Statistik des teuersten Artikel im Array 
{

	TArticle tartikelZwischenspeicher; // Variable wird Initialisiert
	int hoechsterPreis = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].price >= hoechsterPreis) //Vergleicht den Wert "Preis" aus dem Array mit Wert in int hoechsterpreis
		{
			hoechsterPreis = AlleArtikel[i].price;		//�berschreibt Wert in Variable mit h�herem Wert
			tartikelZwischenspeicher = AlleArtikel[i];	//�berschreibt Werte in tartikelZwischenspeicher
		}
	}
	//Ausgabe in Konsole
  std::cout << "Der teuerste Artikel ist: " << tartikelZwischenspeicher.id << 
	std::endl << tartikelZwischenspeicher.name << std::endl << tartikelZwischenspeicher.price;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0x218, %r15d           # imm = 0x218
leaq 0x8(%rsp), %r14
movsd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3274
leaq (%rbx,%r15), %rsi
addq $-0x108, %rsi           # imm = 0xFEF8
cvttsd2si %xmm0, %ebp
movl $0x110, %edx            # imm = 0x110
movq %r14, %rdi
callq 0x20e0
addq $0x110, %r15            # imm = 0x110
cmpq $0x42788, %r15          # imm = 0x42788
jne 0x3245
movq 0x2d3d(%rip), %r14      # 0x5fc8
leaq 0x108b(%rip), %rsi      # 0x431d
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2160
leaq 0xc(%rsp), %rbx
movl -0x4(%rbx), %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movsd 0x104(%rbx), %xmm0
movq %rax, %rdi
callq 0x2210
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/statistics.cpp
// Function: guenstigsterArtikel(TArticle*)
int guenstigsterArtikel(TArticle AlleArtikel[])
{
	
	TArticle tartikelZwischenspeicher;
	int guenstigsterPreis = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].price <= guenstigsterPreis)
		{
			guenstigsterPreis = AlleArtikel[i].price;
			tartikelZwischenspeicher = AlleArtikel[i];
		}
	}

  std::cout << "Der guenstigste Artikel ist: " << tartikelZwischenspeicher.id << 
	std::endl << tartikelZwischenspeicher.name << std::endl << tartikelZwischenspeicher.price;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0x218, %r15d           # imm = 0x218
leaq 0x8(%rsp), %r14
movsd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
ucomisd %xmm0, %xmm1
jb 0x3385
leaq (%rbx,%r15), %rsi
addq $-0x108, %rsi           # imm = 0xFEF8
cvttsd2si %xmm0, %ebp
movl $0x110, %edx            # imm = 0x110
movq %r14, %rdi
callq 0x20e0
addq $0x110, %r15            # imm = 0x110
cmpq $0x42788, %r15          # imm = 0x42788
jne 0x3356
movq 0x2c2c(%rip), %r14      # 0x5fc8
leaq 0xf95(%rip), %rsi       # 0x4338
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2160
leaq 0xc(%rsp), %rbx
movl -0x4(%rbx), %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movsd 0x104(%rbx), %xmm0
movq %rax, %rdi
callq 0x2210
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bastelfreak[P]erp-system/statistics.cpp
// Function: anzahlArtikel(TArticle*)
int anzahlArtikel(TArticle AlleArtikel[])
{

	int anzahl = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].id != '\0')
		{
			 anzahl += 1;
		}
	}

  std::cout << "Die Anzahl der Artikel ist: " << anzahl << std::endl;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0x110, %eax            # imm = 0x110
cmpl $0x1, (%rdi,%rax)
sbbl $-0x1, %ebx
addq $0x110, %rax            # imm = 0x110
cmpq $0x42680, %rax          # imm = 0x42680
jne 0x3455
movq 0x2b57(%rip), %r14      # 0x5fc8
leaq 0xede(%rip), %rsi       # 0x4356
movl $0x1c, %edx
movq %r14, %rdi
callq 0x2160
movq %r14, %rdi
movl %ebx, %esi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::makeMin(sockaddr_in const&, sockaddr_in const&, unsigned char, unsigned char, boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian>&)
inline void
db<ADDR>::makeTuple (const sockaddr_in& src,
                     const sockaddr_in& dst,
                     const u8 proto,
                     const u8 dscp,
                     const s32 offset,
                     tuple<rtacl::ipv4a>& result)
{
    assert(af == AF_INET);

    s64 val;

    val = static_cast<s64>(ntohl(src.sin_addr.s_addr)) + offset;
    bg::set<0>(result, val);
    val = static_cast<s64>(ntohl(dst.sin_addr.s_addr)) + offset;
    bg::set<1>(result, val);
    val = static_cast<s64>(ntohs(src.sin_port)) + offset;
    bg::set<2>(result, val);
    val = static_cast<s64>(ntohs(dst.sin_port)) + offset;
    bg::set<3>(result, val);
    val = static_cast<s64>(proto) + offset;
    bg::set<4>(result, val);
    val = static_cast<s64>(dscp) + offset;
    bg::set<5>(result, val);
}

// Assembly:
cmpw $0x2, 0x18(%rdi)
jne 0x14daa
movl 0x4(%rsi), %eax
bswapl %eax
decq %rax
movq %rax, (%r9)
movl 0x4(%rdx), %eax
bswapl %eax
decq %rax
movq %rax, 0x8(%r9)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
decq %rax
movq %rax, 0x10(%r9)
movzwl 0x2(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
decq %rax
movq %rax, 0x18(%r9)
movzbl %cl, %eax
decq %rax
movq %rax, 0x20(%r9)
movzbl %r8b, %eax
decq %rax
movq %rax, 0x28(%r9)
retq
pushq %rax
leaq 0x274ca(%rip), %rdi     # 0x3c27c
leaq 0x207c7(%rip), %rsi     # 0x35580
leaq 0x274ca(%rip), %rcx     # 0x3c28a
movl $0x25b, %edx            # imm = 0x25B
callq 0x4140
// File: /workspace/github_cpp_makefile_star2_O1/hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0>>::dump() const
inline result<ADDR>
db<ADDR>::dump () const
{
    /*
     * Get an entire copy of the entries
     */
    range<ADDR>  b = rtree.bounds();
    result<ADDR> r;
    rtree.query(bgi::covered_by(b), std::back_inserter(r));

    return r;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x498, %rsp            # imm = 0x498
movq %rsi, %r14
movq %rdi, %rbx
movl $0x22, %eax
pxor %xmm0, %xmm0
movdqa %xmm0, -0x2(%rsp,%rax)
movdqa %xmm0, -0x12(%rsp,%rax)
movw $0x1, 0xe(%rsp,%rax)
movb $0x0, 0x10(%rsp,%rax)
addq $0x30, %rax
cmpq $0x142, %rax            # imm = 0x142
jne 0x155b7
movl $0x142, %eax            # imm = 0x142
leaq 0x130(%rsp), %rcx
pxor %xmm0, %xmm0
movdqa %xmm0, -0x2(%rsp,%rax)
movdqa %xmm0, -0x12(%rsp,%rax)
movw $0x1, 0xe(%rsp,%rax)
movb $0x0, 0x10(%rsp,%rax)
addq $0x30, %rax
cmpq $0x262, %rax            # imm = 0x262
jne 0x155ec
movw $0x4, %ax
movw %ax, 0x30(%rsp)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
movdqa %xmm0, 0x20(%rsp)
xorl %edx, %edx
movb %dl, 0x32(%rsp)
movw %ax, 0x60(%rsp)
movdqa %xmm0, 0x40(%rsp)
movdqa %xmm0, 0x50(%rsp)
movb %dl, 0x62(%rsp)
movw %ax, 0x90(%rsp)
movdqa %xmm0, 0x70(%rsp)
movdqa %xmm0, 0x80(%rsp)
movb %dl, 0x92(%rsp)
movw %ax, 0xc0(%rsp)
movdqa %xmm0, 0xa0(%rsp)
movdqa %xmm0, 0xb0(%rsp)
movb %dl, 0xc2(%rsp)
movw %ax, 0xf0(%rsp)
movdqa %xmm0, 0xd0(%rsp)
movdqa %xmm0, 0xe0(%rsp)
movb %dl, 0xf2(%rsp)
movw %ax, 0x120(%rsp)
movdqa %xmm0, 0x100(%rsp)
movdqa %xmm0, 0x110(%rsp)
movb %dl, 0x122(%rsp)
movw %ax, 0x150(%rsp)
movdqa %xmm0, 0x10(%rcx)
movdqa %xmm0, (%rcx)
movb $0x1, %cl
movb %cl, 0x152(%rsp)
movw %ax, 0x180(%rsp)
movdqa %xmm0, 0x160(%rsp)
movdqa %xmm0, 0x170(%rsp)
movb %cl, 0x182(%rsp)
movw %ax, 0x1b0(%rsp)
movdqa %xmm0, 0x190(%rsp)
movdqa %xmm0, 0x1a0(%rsp)
movb %cl, 0x1b2(%rsp)
movw %ax, 0x1e0(%rsp)
movdqa %xmm0, 0x1c0(%rsp)
movdqa %xmm0, 0x1d0(%rsp)
movb %cl, 0x1e2(%rsp)
movw %ax, 0x210(%rsp)
movdqa %xmm0, 0x1f0(%rsp)
movdqa %xmm0, 0x200(%rsp)
movb %cl, 0x212(%rsp)
movw %ax, 0x240(%rsp)
movdqa %xmm0, 0x230(%rsp)
movdqa %xmm0, 0x220(%rsp)
movb %cl, 0x242(%rsp)
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x157aa
leaq 0x10(%rsp), %rax
leaq 0x250(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
movq %r14, 0x10(%rsi)
callq 0x1e9de
pxor %xmm0, %xmm0
movdqu %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x250(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2013e
cmpq $0x0, 0x10(%r14)
je 0x157eb
leaq 0x250(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1f0f2
movq %rbx, %rax
addq $0x498, %rsp            # imm = 0x498
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x15810
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4210
movq %r14, %rdi
callq 0x4370
// File: /workspace/github_cpp_makefile_star2_O1/hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0>>::find(boost::geometry::model::point<boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0>, 6ul, boost::geometry::cs::cartesian> const&)
inline result<ADDR>
db<ADDR>::find (const tuple<ADDR>& key)
{
    result<ADDR> r;
    size_t n = rtree.query(bgi::contains(key), std::back_inserter(r));
    if (n != r.size()) {
        fprintf(stderr, "n(%ld) != r.size()(%ld)\n", n, r.size());
    }
    assert(n == r.size());

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x22, %eax
movaps -0x22(%rdx,%rax), %xmm0
movaps -0x12(%rdx,%rax), %xmm1
movaps %xmm1, -0x2(%rsp,%rax)
movaps %xmm0, -0x12(%rsp,%rax)
movzwl -0x2(%rdx,%rax), %ecx
movw %cx, 0xe(%rsp,%rax)
movb (%rdx,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
addq $0x30, %rax
cmpq $0x142, %rax            # imm = 0x142
jne 0x158c2
cmpq $0x0, 0x10(%rsi)
je 0x15917
leaq 0x10(%rsp), %rax
leaq 0xf(%rsp), %rcx
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x21b90
movq %rax, %r14
jmp 0x1591a
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x4, %rcx
movabsq $0x14c1bacf914c1bad, %r15 # imm = 0x14C1BACF914C1BAD
imulq %r15, %rcx
cmpq %rcx, %r14
jne 0x1595c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x4, %rax
imulq %r15, %rax
cmpq %rax, %r14
jne 0x15979
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq 0x58665(%rip), %rax     # 0x6dfc8
movq (%rax), %rdi
leaq 0x1fbec(%rip), %rsi     # 0x35559
movq %r14, %rdx
xorl %eax, %eax
callq 0x42d0
jmp 0x15938
leaq 0x1fbf2(%rip), %rdi     # 0x35572
leaq 0x1fbf9(%rip), %rsi     # 0x35580
leaq 0x42837(%rip), %rcx     # 0x581c5
movl $0x23d, %edx            # imm = 0x23D
callq 0x4140
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x159af
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4210
movq %r14, %rdi
callq 0x4370
nop