LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]eph_converter/src/Com.cpp
// Function: mjd2doy(int, int*, int*)
void mjd2doy(int jd, int* iyear, int* idoy) {
	*iyear = (jd + 678940) / 365;
	*idoy = jd - md_julday(*iyear, 1, 1);
	while (*idoy <= 0) {
		(*iyear)--;
		*idoy = jd - md_julday(*iyear, 1, 1) + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
leal 0xa5c1c(%r15), %eax
movl $0x16d, %ecx            # imm = 0x16D
cltd
idivl %ecx
movl %eax, (%rsi)
pushq $0x1
popq %r12
movl %eax, %edi
movl %r12d, %esi
movl %r12d, %edx
callq 0xa4d0
movl %r15d, %ecx
subl %eax, %ecx
incl %r15d
movl %ecx, (%rbx)
testl %ecx, %ecx
jg 0xa657
movl (%r14), %edi
decl %edi
movl %edi, (%r14)
movl %r12d, %esi
movl %r12d, %edx
callq 0xa4d0
movl %r15d, %ecx
subl %eax, %ecx
jmp 0xa637
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]eph_converter/src/Com.cpp
// Function: wksow2mjd(int, double, int*, double*)
void wksow2mjd(int week,double sow,int* mjd,double* sod){
	if(mjd!=NULL)
		*mjd = (int)(sow/86400.0) + week*7 + 44244;
	if(sod!=NULL)
		*sod = fmod(sow,86400.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
je 0xa68a
movapd %xmm0, %xmm1
divsd 0x19b6(%rip), %xmm1     # 0xc030
cvttsd2si %xmm1, %eax
imull $0x7, %edi, %ecx
addl %ecx, %eax
addl $0xacd4, %eax           # imm = 0xACD4
movl %eax, (%rsi)
testq %rbx, %rbx
je 0xa6a0
movsd 0x1999(%rip), %xmm1     # 0xc030
callq 0x3360
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]eph_converter/src/Com.cpp
// Function: blhxyz(double*, double, double, double*)
void blhxyz(double* geod,double a0,double b0,double* x){
	double a,b,e2,N,W;
	if(a0 == 0 || b0 == 0){
		a = 6378137.0;
		b = 298.257223563;  //alpha = (a-b)/a
	}else{
		a = a0;
		b = b0;
	}
	if(b <= 6000000)
		b = a - a / b;
	e2 = (a * a - b * b) / (a * a);

	W = sqrt(1 - e2 * pow(sin(geod[0]),2));
	N = a / W;
	x[0] = (N + geod[2]) * cos(geod[0]) * cos(geod[1]);
	x[1] = (N + geod[2]) * cos(geod[0]) * sin(geod[1]);
	x[2] = (N * (1-e2) + geod[2]) *sin(geod[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm4, %xmm4
movapd %xmm1, %xmm3
cmpeqpd %xmm4, %xmm3
movapd %xmm0, %xmm2
cmpeqpd %xmm4, %xmm2
orpd %xmm3, %xmm2
movd %xmm2, %eax
testb $0x1, %al
je 0xa6e2
movsd 0x2b96(%rip), %xmm1     # 0xd278
je 0xa6ec
movsd 0x2b94(%rip), %xmm0     # 0xd280
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd %xmm1, %xmm3
cmpnlesd 0x2b7f(%rip), %xmm3     # 0xd288
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm3
orpd %xmm1, %xmm3
mulsd %xmm3, %xmm3
movapd %xmm0, -0x30(%rbp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
subsd %xmm3, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd (%r14), %xmm0
callq 0x30a0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd -0x38(%rbp), %xmm1
movsd 0x25d2(%rip), %xmm0     # 0xcd28
subsd %xmm1, %xmm0
ucomisd 0x18e6(%rip), %xmm0     # 0xc048
jb 0xa76a
sqrtsd %xmm0, %xmm0
jmp 0xa76f
callq 0x3200
movapd -0x30(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
movsd 0x10(%r14), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x34a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x34a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x34a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x30a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x2533(%rip), %xmm0     # 0xcd28
subsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
addsd 0x10(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%r14), %xmm0
callq 0x30a0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]eph_converter/src/Com.cpp
// Function: rot_enu2xyz(double, double, double (*) [3])
void rot_enu2xyz(double lat, double lon, double (*rotmat)[3]) {
	double coslat, sinlat, coslon, sinlon;
	coslat = cos(lat - PI / 2);
	sinlat = sin(lat - PI / 2);
	coslon = cos(-PI / 2 - lon);
	sinlon = sin(-PI / 2 - lon);

	rotmat[0][0] = coslon;
	rotmat[0][1] = sinlon * coslat;
	rotmat[0][2] = sinlon * sinlat;
	rotmat[1][0] = -sinlon;
	rotmat[1][1] = coslon * coslat;
	rotmat[1][2] = coslon * sinlat;
	rotmat[2][0] = 0;
	rotmat[2][1] = -sinlat;
	rotmat[2][2] = coslat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd %xmm1, -0x10(%rbp)
addsd 0x26f8(%rip), %xmm0     # 0xd298
movsd %xmm0, -0x20(%rbp)
callq 0x34a0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x30a0
movaps %xmm0, -0x20(%rbp)
movsd 0x26d3(%rip), %xmm0     # 0xd298
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x34a0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x30a0
movsd -0x10(%rbp), %xmm4
movsd %xmm4, (%rbx)
movsd -0x30(%rbp), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
movapd -0x20(%rbp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
movapd 0x21e8(%rip), %xmm1     # 0xce00
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x18(%rbx)
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x20(%rbx)
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm4
movsd %xmm4, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x38(%rbx)
movsd %xmm2, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]eph_converter/src/Com.cpp
// Function: matmpy(double*, double*, double*, int, int, int)
void matmpy(double* A, double* B, double* C, int row, int colA, int colB) {
	int i, j, k;
	double value;
	double* dest = (double*)calloc(row * colB,sizeof(double));
	for (i = 0; i < row; i++) {
		for (j = 0; j < colB; j++) {
			value = 0;
			for (k = 0; k < colA; k++){
				value += A[i * colA + k] * B[k* colB + j];
			}
			dest[i * colB + j] = value;
		}
	}
	for(i = 0;i <row;i++){
		for(j = 0;j < colB;j++){
			C[i * colB + j] = dest[i * colB + j];
		}
	}
	free(dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, %r13d
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %r12
movl %r9d, %eax
imull %ecx, %eax
movslq %eax, %rdi
pushq $0x8
popq %rsi
callq 0x31c0
movq %rax, -0x30(%rbp)
movslq %r15d, %rax
xorl %edi, %edi
testl %r13d, %r13d
movl $0x0, %r8d
cmovgl %r13d, %r8d
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movslq %r13d, %r9
testl %ebx, %ebx
cmovlel %edi, %ebx
shlq $0x3, %r9
leaq (,%rax,8), %rdx
cmpq %rbx, %rdi
je 0xad19
movq %rdi, %rsi
imulq %rax, %rsi
movq -0x30(%rbp), %r10
leaq (%r10,%rsi,8), %r10
movq -0x38(%rbp), %r15
xorl %r13d, %r13d
cmpq %rcx, %r13
je 0xad11
xorpd %xmm0, %xmm0
movq %r15, %r11
xorl %esi, %esi
cmpq %rsi, %r8
je 0xad02
movsd (%r12,%rsi,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
incq %rsi
addq %rdx, %r11
jmp 0xace6
movsd %xmm0, (%r10,%r13,8)
incq %r13
addq $0x8, %r15
jmp 0xacd8
incq %rdi
addq %r9, %r12
jmp 0xacbd
xorl %esi, %esi
movq -0x30(%rbp), %rdi
cmpq %rbx, %rsi
je 0xad46
xorl %eax, %eax
cmpq %rax, %rcx
je 0xad3b
movsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0xad26
incq %rsi
addq %rdx, %rdi
addq %rdx, %r14
jmp 0xad1f
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3310
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3140
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmpq %rdx, %rcx
je 0xad8c
cmpb %bl, (%r14,%rdx)
je 0xad8a
incq %rdx
jmp 0xad7a
movl %edx, %ecx
cmpl %eax, %ecx
pushq $-0x1
popq %rax
cmovnel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3140
movq %rax, %rcx
movl %ecx, %edx
sarl $0x1f, %eax
andl %ecx, %eax
movabsq $0x100002401, %rcx      # imm = 0x100002401
testl %edx, %edx
jle 0xadd7
movzbl -0x1(%rbx,%rdx), %esi
cmpq $0x20, %rsi
ja 0xadd5
btq %rsi, %rcx
jae 0xadd5
decq %rdx
jmp 0xadbb
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movsd 0x1edb(%rip), %xmm1     # 0xcd68
xorl %r15d, %r15d
ucomisd %xmm0, %xmm1
seta %r15b
pushq $0x4
popq %r14
subl %r15d, %r14d
callq 0xad99
pushq $0x50
popq %rcx
subl %r15d, %ecx
cltq
cmpq %rcx, %rax
jge 0xaeba
movb $0x20, (%rbx,%rax)
incq %rax
jmp 0xaeac
movb $0x0, (%rbx,%rcx)
movl %r14d, %r15d
addq %rbx, %r15
xorl %r12d, %r12d
leaq -0xa0(%rbp), %rbx
pushq $0x13
popq %r14
cmpq $0x4c, %r12
je 0xaf01
leaq (%r15,%r12), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xaf11
movq %rbx, %rdi
callq 0xad99
testl %eax, %eax
jne 0xaefb
movb $0x30, 0x1(%r15,%r12)
addq $0x13, %r12
jmp 0xaed2
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3140
testl %r12d, %r12d
setns %cl
cmpl %r12d, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xaf4b
addl %r12d, %r14d
cmpl %eax, %r14d
jle 0xaf52
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0xaf71
movl %r12d, %ecx
addq %rcx, %r15
xorl %eax, %eax
leal (%rcx,%rax), %edx
cmpl %edx, %r14d
jle 0xaf6e
movb (%r15,%rax), %dl
movb %dl, (%rbx,%rax)
incq %rax
jmp 0xaf5a
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_O2/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 0xaf9b
leaq 0x237f(%rip), %rsi      # 0xd310
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
retq
cmpl $0x52, %edi
jne 0xb025
pushq %rbp
movq %rsp, %rbp
addsd 0x2300(%rip), %xmm0     # 0xd2b0
movsd 0x1078(%rip), %xmm1     # 0xc030
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 0x22c3(%rip), %xmm2     # 0xd2b8
movapd %xmm2, %xmm0
callq 0x3360
divsd 0x104a(%rip), %xmm0     # 0xc050
xorl %eax, %eax
ucomisd 0x1038(%rip), %xmm0     # 0xc048
seta %al
leaq 0x22e6(%rip), %rcx      # 0xd300
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
pushq $-0x1
popq %rax
retq
cvttsd2si 0x100(%rcx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xfee(%rip), %xmm1      # 0xc030
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 0xb080
decl %eax
movl %eax, (%rsi)
addsd 0xfb4(%rip), %xmm0      # 0xc030
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x8, %ecx
subq $0x1, %rdi
jb 0xb543
movzbl (%rsi), %edx
shll $0x10, %edx
xorq %rdx, %rax
movl %ecx, %edx
subl $0x1, %edx
jb 0xb53e
leaq (%rax,%rax), %r8
movq %r8, %r9
xorq $0x1864cfb, %r9         # imm = 0x1864CFB
btl $0x17, %eax
cmovaeq %r8, %r9
movq %r9, %rax
jmp 0xb51e
incq %rsi
jmp 0xb50d
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%r14)
movq %r14, %rdx
callq 0xa5f9
movl (%r13), %edi
movl (%r14), %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xb62f
movsd 0xa59(%rip), %xmm0      # 0xc010
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 0xa1e(%rip), %xmm1      # 0xc008
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
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_O2/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
movq %rdx, %r8
movaps 0x1d43(%rip), %xmm0     # 0xd380
movaps %xmm0, -0x10(%rbp)
movaps 0x1d28(%rip), %xmm0     # 0xd370
movaps %xmm0, -0x20(%rbp)
movaps 0x1d0d(%rip), %xmm0     # 0xd360
movaps %xmm0, -0x30(%rbp)
testb $0x3, %dil
sete %r9b
movl $0x64, %r10d
movl %edi, %eax
cltd
idivl %r10d
testl %edx, %edx
setne %r10b
movl $0x190, %r11d           # imm = 0x190
movl %edi, %eax
cltd
idivl %r11d
testl %edx, %edx
je 0xb686
andb %r10b, %r9b
je 0xb68d
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
cmpq $0xc, %rax
je 0xb6ab
movl %esi, %edx
subl -0x30(%rbp,%rax,4), %edx
jle 0xb6a4
incq %rax
movl %edx, %esi
jmp 0xb68f
movl %esi, (%rcx)
incl %eax
movl %eax, (%r8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
andq $0x0, (%rcx)
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %r12d
xorpd %xmm0, %xmm0
cmpq %rax, %r12
je 0xb6f0
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %rax
jmp 0xb6d4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xb700
sqrtsd %xmm0, %xmm0
jmp 0xb705
callq 0x3200
movsd %xmm0, (%rbx)
xorl %eax, %eax
cmpq %rax, %r12
je 0xb725
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0xb70b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
leaq 0x20(%rsp), %r14
movq %rdi, %rbx
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x21b0
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r15
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
vmovups %xmm0, (%rbx)
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2362
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2520
jmp 0x233c
movq %rsp, %rdi
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rsp, %rdi
movq %rax, %r14
callq 0x2090
movq %rbx, %rdi
callq 0x254c
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: main
int main() {
  string line;
  getline(cin, line);
  vector<string> items = parse_line(line);
  vector<vector<string>> options;
  while (getline(cin, line)) {
    vector<string> option = parse_line(line);
    if (!option.empty()) {
      options.push_back(option);
    }
  }
  ExactCover ec(items, options);
  //ec.print();
  //ec.write_dot();
  cout << "Number of solutions: " << ec.run() << "\n";
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x5c11(%rip), %rdi      # 0x7fe0
movq %rsp, %rsi
callq 0x2030
leaq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0x22fc
leaq 0x20(%rsp), %rbx
movq 0x5bf0(%rip), %r14      # 0x7fe0
vxorps %xmm0, %xmm0, %xmm0
leaq 0x50(%rsp), %r12
movq %rsp, %r15
andq $0x0, 0x10(%rbx)
vmovaps %xmm0, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x244a
movq %r12, %rdi
movq %r15, %rsi
callq 0x22fc
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x2440
movq %rbx, %rdi
movq %r12, %rsi
callq 0x256e
movq %r12, %rdi
callq 0x254c
jmp 0x2405
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x259a
movq 0x5b6b(%rip), %rdi      # 0x7fd0
leaq 0x2b98(%rip), %rsi      # 0x5004
callq 0x2100
leaq 0x50(%rsp), %rdi
movq %rax, %rbx
callq 0x2682
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20f0
leaq 0x2b8a(%rip), %rsi      # 0x501a
movq %rax, %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x26b2
leaq 0x20(%rsp), %rdi
callq 0x26e4
leaq 0x38(%rsp), %rdi
callq 0x254c
movq %rsp, %rdi
callq 0x2090
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24f8
jmp 0x24d3
movq %rax, %rbx
jmp 0x250f
leaq 0x50(%rsp), %rdi
movq %rax, %rbx
callq 0x26b2
jmp 0x24fb
leaq 0x50(%rsp), %rdi
movq %rax, %rbx
callq 0x254c
jmp 0x24fb
jmp 0x24f8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x26e4
leaq 0x38(%rsp), %rdi
callq 0x254c
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::run()
long run() {
    count = 0;
    active = header.size() - 1;
    solve(0);
    if (DEBUG) {
      for (int i = 0; i < int(hist.size()) - 1; i++) {
        if (hist[i] > 0) {
          cout << "hist "<< i << " = " << hist[i] << "\n";
        }
      }
    }
    return count;
  }

// Assembly:
pushq %rbx
andq $0x0, 0xb0(%rdi)
xorl %esi, %esi
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xa8(%rdi)
callq 0x370c
movq 0xb0(%rbx), %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rdx), %rsi
movq %rdx, %r14
movq %rdi, %rbx
subq (%rdx), %rsi
leaq 0x7(%rsp), %rdx
sarq $0x5, %rsi
incq %rsi
callq 0x2ae8
movq 0x8(%r14), %rcx
movq (%rbx), %rdi
xorl %r9d, %r9d
subq (%r14), %rcx
shrq $0x5, %rcx
leal 0x1(%rcx), %esi
movslq %ecx, %r8
cmpq %r8, %r9
jg 0x276d
testq %r9, %r9
je 0x275f
leal 0x1(%r9), %eax
cltd
idivl %esi
leal -0x1(%r9), %eax
movl %eax, (%rdi,%r9,8)
movl %edx, 0x4(%rdi,%r9,8)
jmp 0x2768
movl %ecx, (%rdi)
movl $0x1, 0x4(%rdi)
incq %r9
jmp 0x273f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rax)
je 0x37dd
movq %rbx, %rdi
movl %esi, %r14d
callq 0x37ee
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x3828
movq 0x18(%rbx), %rcx
movslq %ebp, %rax
movq 0x38(%rbx), %r12
movslq %r14d, %r14
imulq $0xc, %rax, %rax
imulq $0xc, %r14, %r15
incl %r14d
leaq 0x8(%rcx,%rax), %rax
addq %r15, %r12
movl (%rax), %esi
movl %esi, (%r12)
cmpl %ebp, %esi
je 0x37cb
movq 0x38(%rbx), %rdx
movq %rbx, %rdi
addq %r15, %rdx
callq 0x387e
cmpl $0x1, 0xa8(%rbx)
jne 0x379a
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x4(%rax), %rax
imulq $0xc, %rax, %rax
movslq (%rcx,%rax), %rax
addq %rax, 0xb0(%rbx)
jmp 0x37a5
movq %rbx, %rdi
movl %r14d, %esi
callq 0x370c
movq 0x38(%rbx), %rdx
movl (%r12), %esi
movq %rbx, %rdi
addq %r15, %rdx
callq 0x388c
movslq (%r12), %rax
movq 0x18(%rbx), %rcx
imulq $0xc, %rax, %rax
leaq 0x8(%rcx,%rax), %rax
jmp 0x375c
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3894
incq 0xb0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
decl 0xa8(%rdi)
movslq %esi, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %r15, %r14
movq 0x18(%rbx), %rax
imulq $0xc, %r14, %rcx
movl 0x8(%rax,%rcx), %eax
cmpl %ebp, %eax
je 0x3860
movslq %eax, %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38e2
jmp 0x3840
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_O2/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 %r15
pushq %r14
pushq %rbx
incl 0xa8(%rdi)
movslq %esi, %r15
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movslq (%rax,%r15,8), %rcx
movslq 0x4(%rax,%r15,8), %rdx
movl %r15d, 0x4(%rax,%rcx,8)
movl %r15d, (%rax,%rdx,8)
movq 0x18(%r14), %rax
imulq $0xc, %r15, %rcx
movl 0x4(%rax,%rcx), %eax
cmpl %ebx, %eax
je 0x38dc
movslq %eax, %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x3ace
jmp 0x38bc
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: void ExactCover::option_right_edges<ExactCover::try_option(int, Solution&)::'lambda'(int), ExactCover::try_option(int, Solution&)::'lambda0'(int), ExactCover::try_option(int, Solution&)::'lambda1'(int)>(int, ExactCover::try_option(int, Solution&)::'lambda'(int), ExactCover::try_option(int, Solution&)::'lambda0'(int), ExactCover::try_option(int, Solution&)::'lambda1'(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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
movslq %esi, %rcx
movq %r8, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r12d
movq 0x18(%rdi), %rax
imulq $0xc, %rcx, %rbx
cmpl $0x0, (%rax,%rbx)
jle 0x3a02
leaq 0xc(%rbx), %r15
movq %rsp, %r13
movl %ebp, %r12d
incl %r12d
movq %r13, %rdi
movl %r12d, %esi
callq 0x3a46
movq 0x18(%r14), %rax
cmpl $0x0, (%rax,%r15)
leaq 0xc(%r15), %r15
jg 0x39e5
movq 0x8(%rsp), %rcx
addq $-0xc, %rbx
movq %rsp, %r15
movl %r12d, 0x8(%rcx)
cmpl $0x0, (%rax,%rbx)
jle 0x3a2e
decl %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x3a46
movq 0x18(%r14), %rax
addq $-0xc, %rbx
jmp 0x3a12
movq 0x10(%rsp), %rax
movl %ebp, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::hide(int)::'lambda'(int)::operator()(int) const
void hide(int p) {
    option_right(p, [&](int q) {
      auto x = abs(nodes[q].top);
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = d;
      nodes[d].ulink = u;
      nodes[x].top--;
    });
  }

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
imulq $0xc, %rcx, %rcx
movq 0x18(%rax), %rax
movl (%rax,%rcx), %edx
movl %edx, %esi
negl %esi
cmovsl %edx, %esi
movslq 0x4(%rax,%rcx), %rdx
movslq 0x8(%rax,%rcx), %rcx
imulq $0xc, %rdx, %rdi
movl %ecx, 0x8(%rax,%rdi)
imulq $0xc, %rcx, %rcx
movl %edx, 0x4(%rax,%rcx)
imulq $0xc, %rsi, %rcx
decl (%rax,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::try_option(int, Solution&)::'lambda'(int)::operator()(int) const
void try_option(int option, Solution& sol) {
    option_right_edges(option, [&](int p) {
      cover(abs(nodes[p].top));
    }, [&sol](int right) {
      sol.right = right;
    }, [&sol](int left) {
      sol.left = left;
    });
  }

// Assembly:
movq (%rdi), %rdi
movslq %esi, %rax
imulq $0xc, %rax, %rax
movq 0x18(%rdi), %rcx
movl (%rcx,%rax), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
jmp 0x3828
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsp, %r15
movq %rcx, (%r15)
movq %rdx, %r14
movl %esi, %ebx
movl 0x4(%rdx), %ebp
cmpl %ebp, %ebx
je 0x3a8b
movq %r15, %rdi
movl %ebp, %esi
callq 0x3ab0
incl %ebp
jmp 0x3a79
movl 0x8(%r14), %ebp
movq %rsp, %r14
cmpl %ebp, %ebx
je 0x3aa4
movq %r14, %rdi
movl %ebp, %esi
callq 0x3ab0
decl %ebp
jmp 0x3a92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::unhide(int)::'lambda'(int)::operator()(int) const
void unhide(int p) {
    option_right(p, [&](int q) {
      auto x = abs(nodes[q].top);
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = q;
      nodes[d].ulink = q;
      nodes[x].top++;
    });
  }

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
imulq $0xc, %rcx, %rdx
movq 0x18(%rax), %rax
movl (%rax,%rdx), %esi
movslq 0x4(%rax,%rdx), %r8
movslq 0x8(%rax,%rdx), %rdx
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
imulq $0xc, %r8, %rsi
imulq $0xc, %rdx, %rdx
movl %ecx, 0x8(%rax,%rsi)
movl %ecx, 0x4(%rax,%rdx)
imulq $0xc, %rdi, %rcx
incl (%rax,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/bastelfreak[P]erp-system/articlesearch.cpp
// Function: ArtikelNummerSuche()
int ArtikelNummerSuche()
{
	int ArtikelNummer;
	// cout<< "Bitte geben Sie nun die Artikel-Nummer ein" <<endl;
  std::cout<< "Please enter the Article Number" << std::endl;
  std::cin >> ArtikelNummer;

	return ArtikelNummer;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x2952(%rip), %rdi      # 0x4fc8
leaq 0xa59(%rip), %rsi       # 0x30d6
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movq 0x2947(%rip), %rdi      # 0x4fd8
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x20b0
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x2904(%rip), %rdi      # 0x4fc8
leaq 0xa2b(%rip), %rsi       # 0x30f6
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movq 0x28f9(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/bastelfreak[P]erp-system/articlesearch.cpp
// Function: ArtikelPreisSuche()
double ArtikelPreisSuche ()
{
	double ArtikelPreis;
	//cout<< "Bitte geben Sie den Preis des Produktes ein!" <<endl;
  std::cout << "Please enter the Article Price" << std::endl;
  std::cin >> ArtikelPreis;

	return ArtikelPreis;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x28b7(%rip), %rdi      # 0x4fc8
leaq 0x9fc(%rip), %rsi       # 0x3114
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movq 0x28ac(%rip), %rdi      # 0x4fd8
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x20c0
movsd (%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x2727(%rip), %rdi      # 0x4fc8
leaq 0x8b5(%rip), %rsi       # 0x315d
callq 0x2130
movq 0x2724(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2844
testb %al, %al
je 0x290f
movq (%r14), %rsi
pushq $0x18
popq %rdx
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x2110
movq 0x26b2(%rip), %rbx      # 0x4fc8
leaq 0x87a(%rip), %rsi       # 0x3197
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
leaq 0x866(%rip), %rsi       # 0x319d
movq %rax, %rdi
callq 0x2130
movq %rsp, %r15
movq %r15, %rdi
callq 0x2883
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2090
movq (%r14), %rsi
movq %rsp, %rdi
pushq $0x10
popq %rdx
callq 0x2140
leaq 0x70(%rsp), %rdi
callq 0x2050
testb %al, %al
cmoveq 0x2671(%rip), %rbx      # 0x4ff0
leaq 0x83c(%rip), %rax       # 0x31c2
leaq 0x81d(%rip), %rsi       # 0x31aa
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x2130
movq %rsp, %rdi
callq 0x21c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
leaq 0x80(%rsi), %rdi
callq 0x2050
testb %al, %al
je 0x29ec
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
jmp 0x29ff
movq 0x25d5(%rip), %rdi      # 0x4fc8
leaq 0x7d7(%rip), %rsi       # 0x31d1
callq 0x2130
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x2050
testb %al, %al
je 0x2afb
xorl %ebp, %ebp
leaq 0x79b(%rip), %r12       # 0x31e4
movq %rbx, (%rsp)
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x2b27
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x2070
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21f0
imulq $0x110, %rbp, %rcx      # imm = 0x110
movq 0x8(%rsp), %rdx
leaq (%rdx,%rcx), %r15
addq $0x108, %r15            # imm = 0x108
leaq (%rdx,%rcx), %rbx
leaq 0x4(%rdx,%rcx), %r13
pushq $0x1
popq %r14
testq %rax, %rax
je 0x2aef
cmpl $0x3, %r14d
je 0x2ad3
cmpl $0x2, %r14d
je 0x2ac6
cmpl $0x1, %r14d
jne 0x2ae0
movq %rax, %rdi
callq 0x21e0
movl %eax, (%rbx)
jmp 0x2ae0
movq %r13, %rdi
movq %rax, %rsi
callq 0x2120
jmp 0x2ae0
movq %rax, %rdi
callq 0x2170
movsd %xmm0, (%r15)
xorl %edi, %edi
movq %r12, %rsi
callq 0x21f0
incl %r14d
jmp 0x2aa3
incq %rbp
movq (%rsp), %rbx
jmp 0x2a4d
movq 0x24c6(%rip), %rdi      # 0x4fc8
leaq 0x6c8(%rip), %rsi       # 0x31d1
callq 0x2130
movq %rax, %rdi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x692(%rip), %rsi       # 0x31e6
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x2744
leaq 0x50(%rsp), %rdi
callq 0x2150
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x21b0
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x28da
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x50(%rsp), %rdi
leaq 0x260(%rsp), %rsi
callq 0x2a13
movq 0x241a(%rip), %rdi      # 0x4fc8
leaq 0x63e(%rip), %rsi       # 0x31f3
callq 0x2130
leaq 0x260(%rsp), %rbx
movq 0x23ff(%rip), %r14      # 0x4fc8
leaq 0x65c(%rip), %r15       # 0x322c
leaq 0x744(%rip), %r12       # 0x331b
movq 0x23fa(%rip), %r13      # 0x4fd8
leaq 0xf(%rsp), %rbp
movq %rbx, %rdi
callq 0x2c74
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, %rdi
movq %r12, %rsi
callq 0x2130
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2190
movb 0xf(%rsp), %al
addb $-0x59, %al
testb $-0x22, %al
jne 0x2be3
leaq 0x50(%rsp), %rdi
callq 0x2040
leaq 0x30(%rsp), %rdi
callq 0x2090
xorl %eax, %eax
addq $0x428e8, %rsp          # imm = 0x428E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
jmp 0x2c57
movq %rax, %rbx
jmp 0x2c61
jmp 0x2c54
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2040
leaq 0x30(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x233f(%rip), %r14      # 0x4fc8
leaq 0x5d0(%rip), %rsi       # 0x3260
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x5e4(%rip), %rsi       # 0x328b
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x5e4(%rip), %rsi       # 0x32a2
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x5e7(%rip), %rsi       # 0x32bc
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x5e4(%rip), %rsi       # 0x32d0
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x5e0(%rip), %r15       # 0x32e3
movq 0x22ce(%rip), %r12      # 0x4fd8
leaq 0x7(%rsp), %r13
leaq 0x53a(%rip), %rbp       # 0x3250
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq %r12, %rdi
movq %r13, %rsi
callq 0x2190
movzbl 0x7(%rsp), %eax
addl $-0x31, %eax
cmpl $0x3, %eax
ja 0x2d6b
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x2d90
jmp 0x2d16
movq %rbx, %rdi
callq 0x2f02
jmp 0x2d16
movq %rbx, %rdi
callq 0x240c
jmp 0x2d16
movq %rbx, %rdi
callq 0x2e49
jmp 0x2d16
movq 0x2256(%rip), %rdi      # 0x4fc8
leaq 0x586(%rip), %rsi       # 0x32ff
callq 0x2130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x42788, %r15          # imm = 0x42788
je 0x2deb
movsd (%rbx,%r15), %xmm0
cvtsi2sd %ebp, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2de2
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
jmp 0x2dad
movq 0x21d6(%rip), %rdi      # 0x4fc8
leaq 0x524(%rip), %rsi       # 0x331d
callq 0x2130
leaq 0xc(%rsp), %rbx
movl -0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movsd 0x104(%rbx), %xmm0
movq %rax, %rdi
callq 0x2200
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x42788, %r15          # imm = 0x42788
je 0x2ea4
movsd (%rbx,%r15), %xmm0
cvtsi2sd %ebp, %xmm1
ucomisd %xmm0, %xmm1
jb 0x2e9b
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
jmp 0x2e66
movq 0x211d(%rip), %rdi      # 0x4fc8
leaq 0x486(%rip), %rsi       # 0x3338
callq 0x2130
leaq 0xc(%rsp), %rbx
movl -0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movsd 0x104(%rbx), %xmm0
movq %rax, %rdi
callq 0x2200
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
xorl %ebx, %ebx
movl $0x110, %eax            # imm = 0x110
cmpq $0x42680, %rax          # imm = 0x42680
je 0x2f21
cmpl $0x1, (%rdi,%rax)
sbbl $-0x1, %ebx
addq $0x110, %rax            # imm = 0x110
jmp 0x2f0a
movq 0x20a0(%rip), %rdi      # 0x4fc8
leaq 0x427(%rip), %rsi       # 0x3356
callq 0x2130
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
popq %rbx
retq