LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_readClk(char const*, int, double, double*, int*)
int RnxNavFile::v_readClk(const char* cprn, int mjd, double sod, double* sclk,
		int* iode) {
	int wk;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x44(%rbp), %r13
leaq -0x50(%rbp), %rbx
movl %edx, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xb338
movq $0x0, (%r14)
movzbl (%r15), %eax
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0xa8ed
cmpl $0x43, %eax
jne 0xa8ba
addsd 0x3566(%rip), %xmm0     # 0xde20
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x40(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x365f(%rip), %rsi      # 0xdf30
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0xa914
movq (%r12), %rax
leaq -0x38(%rbp), %r10
leaq 0x3634(%rip), %rsi      # 0xdf30
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]eph_converter/src/Com.cpp
// Function: md_julday(int, int, int)
int md_julday(int iyear,int imonth,int iday){
	int iyr, result;
	int doy_of_month[12] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304,
			334 };
	if (iyear < 0 || imonth < 0 || iday < 0 || imonth > 12 || iday > 366
			|| (imonth != 0 && iday > 31)) {
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		exit(1);
	}
	iyr = iyear;
	if (imonth <= 2)
		iyr -= 1;
	result = 365 * iyear - 678941 + iyr / 4 - iyr / 100 + iyr / 400 + iday;
	if (imonth != 0)
		result = result + doy_of_month[imonth - 1];
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %r14d
cmpl $0x16e, %edx            # imm = 0x16E
jg 0xaa40
cmpl $0xc, %ebx
jg 0xaa40
movl %ebx, %eax
orl %r14d, %eax
orl %r15d, %eax
js 0xaa40
testl %ebx, %ebx
sete %al
cmpl $0x20, %r15d
setl %cl
orb %al, %cl
je 0xaa40
xorl %eax, %eax
cmpl $0x3, %ebx
setl %al
movl %r14d, %ecx
subl %eax, %ecx
imull $0x16d, %r14d, %edx     # imm = 0x16D
addl %r15d, %edx
negl %eax
addl %r14d, %eax
addl $0x3, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x2, %eax
addl %edx, %eax
movslq %ecx, %rcx
imulq $-0x51eb851f, %rcx, %rdx # imm = 0xAE147AE1
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x25, %rdx
addl %esi, %edx
addl %eax, %edx
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
addl %edx, %eax
addl $0xfff5a3e3, %eax       # imm = 0xFFF5A3E3
testl %ebx, %ebx
je 0xaa37
decl %ebx
leaq 0x392c(%rip), %rcx      # 0xe360
addl (%rcx,%rbx,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3979(%rip), %r12      # 0xe3c0
movq %r12, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x3050
movq %r12, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x3050
movl $0x1, %edi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]eph_converter/src/Com.cpp
// Function: gpsweek(int, int, int, int*, int*)
void gpsweek(int year, int month, int day, int* week, int* wd) {
	int mjd;
	if (year != 0) {
		if (month != 0)
			mjd = md_julday(year, month, day);
		else
			mjd = md_julday(year, 1, 1) + day - 1;
	} else
		mjd = day;
	*week = (mjd - 44244) / 7;
	*wd = mjd - 44244 - (*week) * 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
testl %edi, %edi
je 0xaab2
testl %esi, %esi
je 0xaa9d
movl %r14d, %edx
callq 0xa984
movl %eax, %r14d
jmp 0xaab2
movl $0x1, %esi
movl $0x1, %edx
callq 0xa984
addl %eax, %r14d
decl %r14d
movl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
cltq
imulq $-0x6db6db6d, %rax, %rax # imm = 0x92492493
shrq $0x20, %rax
addl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
movl %eax, (%r15)
leal (,%rax,8), %ecx
subl %ecx, %eax
addl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
leal 0xa5c1c(%r15), %eax
cltq
imulq $-0x4c73064f, %rax, %rax # imm = 0xB38CF9B1
shrq $0x20, %rax
leal (%rax,%r15), %edi
addl $0xa5c1c, %edi          # imm = 0xA5C1C
movl %edi, %eax
shrl $0x1f, %eax
sarl $0x8, %edi
addl %eax, %edi
movl %edi, (%rsi)
movl $0x1, %esi
movl $0x1, %edx
callq 0xa984
movl %r15d, %ecx
subl %eax, %ecx
movl %ecx, (%rbx)
jg 0xab74
incl %r15d
movl (%r14), %edi
decl %edi
movl %edi, (%r14)
movl $0x1, %esi
movl $0x1, %edx
callq 0xa984
movl %r15d, %ecx
subl %eax, %ecx
movl %ecx, (%rbx)
testl %ecx, %ecx
jle 0xab52
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xabaf
movapd %xmm0, %xmm1
divsd 0x2497(%rip), %xmm1     # 0xd030
cvttsd2si %xmm1, %eax
leal (,%rdi,8), %ecx
subl %edi, %ecx
addl %ecx, %eax
addl $0xacd4, %eax           # imm = 0xACD4
movl %eax, (%rsi)
testq %rbx, %rbx
je 0xabc5
movsd 0x2474(%rip), %xmm1     # 0xd030
callq 0x33a0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xac07
movsd 0x36a1(%rip), %xmm1     # 0xe2a8
je 0xac11
movsd 0x369f(%rip), %xmm0     # 0xe2b0
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd %xmm1, %xmm3
cmpnlesd 0x368a(%rip), %xmm3     # 0xe2b8
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 0x30dd(%rip), %xmm0     # 0xdd58
subsd %xmm1, %xmm0
ucomisd 0x23c1(%rip), %xmm0     # 0xd048
jb 0xac8f
sqrtsd %xmm0, %xmm0
jmp 0xac94
callq 0x3230
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 0x34e0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x34e0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x34e0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x30a0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x303e(%rip), %xmm0     # 0xdd58
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_O3/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 0x320c(%rip), %xmm0     # 0xe2c8
movsd %xmm0, -0x20(%rbp)
callq 0x34e0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x30a0
movaps %xmm0, -0x20(%rbp)
movsd 0x31e7(%rip), %xmm0     # 0xe2c8
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x34e0
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 0x2cfc(%rip), %xmm1     # 0xde30
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)
movq $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_O3/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 $0x28, %rsp
movl %r9d, %ebx
movl %r8d, %r13d
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movl %r9d, %eax
imull %ecx, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x31d0
movq %rax, -0x30(%rbp)
testl %r15d, %r15d
jle 0xb274
movq %r14, -0x40(%rbp)
movl %ebx, %r12d
movl %r15d, -0x34(%rbp)
movl %r15d, %r14d
movl %r13d, %eax
leaq (,%r12,8), %rcx
xorl %edx, %edx
xorl %esi, %esi
testl %ebx, %ebx
jle 0xb235
movl %edx, %edi
movq -0x48(%rbp), %r8
leaq (%r8,%rdi,8), %rdi
movq %rsi, %r8
imulq %r12, %r8
movq -0x30(%rbp), %r9
leaq (%r9,%r8,8), %r8
movq -0x50(%rbp), %r9
xorl %r10d, %r10d
xorpd %xmm0, %xmm0
testl %r13d, %r13d
jle 0xb223
movq %r9, %r11
xorl %r15d, %r15d
movsd (%rdi,%r15,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
incq %r15
addq %rcx, %r11
cmpq %r15, %rax
jne 0xb209
movsd %xmm0, (%r8,%r10,8)
incq %r10
addq $0x8, %r9
cmpq %r12, %r10
jne 0xb1fa
incq %rsi
addl %r13d, %edx
cmpq %r14, %rsi
jne 0xb1d6
cmpl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %r15
jle 0xb274
shlq $0x3, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0xb26c
movl %r13d, %eax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rax,8), %rsi
leaq (%r15,%rax,8), %rdi
movq %r12, %rdx
callq 0x3240
addl %ebx, %r13d
decq %r14
jne 0xb251
movq -0x30(%rbp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb2bc
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb %bl, (%r14,%rcx)
je 0xb2be
incq %rcx
cmpq %rcx, %rdx
jne 0xb2aa
movl %eax, %ecx
jmp 0xb2be
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_O3/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 0xb30e
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movabsq $0x100002401, %rcx      # imm = 0x100002401
movzbl -0x1(%rbx,%rax), %edx
cmpq $0x20, %rdx
ja 0xb30e
btq %rdx, %rcx
jae 0xb30e
decq %rax
leaq 0x1(%rax), %rdx
cmpq $0x1, %rdx
ja 0xb2ee
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movsd 0x29ce(%rip), %xmm1     # 0xdd98
xorl %r14d, %r14d
ucomisd %xmm0, %xmm1
movq %rdi, %rbx
setbe %r14b
leal 0x3(%r14), %r15d
callq 0xb2cd
addq $0x4f, %r14
cmpl %r14d, %eax
jge 0xb405
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
leaq -0x8d(%rbp), %r15
xorl %r12d, %r12d
leaq -0xa0(%rbp), %rbx
leaq (%r14,%r12), %rdi
callq 0x3150
movq %rbx, %rcx
cmpl $0x13, %eax
jl 0xb44e
movl 0xf(%r14,%r12), %eax
movl %eax, -0x91(%rbp)
movupd (%r14,%r12), %xmm0
movapd %xmm0, -0xa0(%rbp)
movq %r15, %rcx
movb $0x0, (%rcx)
movq %rbx, %rdi
callq 0xb2cd
testl %eax, %eax
jne 0xb463
movb $0x30, 0x1(%r14,%r12)
addq $0x13, %r12
cmpq $0x4c, %r12
jne 0xb421
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb4b7
leal (%r12,%r15), %ecx
cmpl %eax, %ecx
jle 0xb4be
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0xb4e6
testl %r12d, %r12d
jle 0xb4e1
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 0xb4cb
movl %edx, %eax
jmp 0xb4e3
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_O3/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 0xb510
leaq 0x2e3a(%rip), %rsi      # 0xe340
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
retq
cmpl $0x52, %edi
jne 0xb59a
pushq %rbp
movq %rsp, %rbp
addsd 0x2dbb(%rip), %xmm0     # 0xe2e0
movsd 0x1b03(%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 0x2d7e(%rip), %xmm2     # 0xe2e8
movapd %xmm2, %xmm0
callq 0x33a0
divsd 0x1ad5(%rip), %xmm0     # 0xd050
xorl %eax, %eax
ucomisd 0x1ac3(%rip), %xmm0     # 0xd048
seta %al
leaq 0x2da1(%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_O3/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 0x1a77(%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 0xb5f7
decl %eax
movl %eax, (%rsi)
addsd 0x1a3d(%rip), %xmm0     # 0xd030
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbd4e
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 0xbd27
incq %rsi
testq %rdi, %rdi
jne 0xbd16
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbdb0
pushq %rbp
movq %rsp, %rbp
movsd (%rdx), %xmm0
addsd 0x12af(%rip), %xmm0     # 0xd018
movsd 0x12bf(%rip), %xmm1     # 0xd030
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addl (%rsi), %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 0xbdaf
decl %eax
movl %eax, (%rsi)
addsd 0x1285(%rip), %xmm0     # 0xd030
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2526(%rip), %xmm0     # 0xe3b0
movaps %xmm0, -0x10(%rbp)
movaps 0x250b(%rip), %xmm0     # 0xe3a0
movaps %xmm0, -0x20(%rbp)
movaps 0x24f0(%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 0xbedb
andb %dil, %al
je 0xbee2
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
movl %esi, %edi
subl -0x30(%rbp,%rax,4), %edi
jle 0xbef9
incq %rax
movl %edi, %esi
cmpq $0xc, %rax
jne 0xbee6
jmp 0xbeff
movl %esi, (%rcx)
incl %eax
movl %eax, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x0, (%rcx)
testl %edi, %edi
jle 0xbf59
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
movl %edi, %r13d
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %rax
cmpq %rax, %r13
jne 0xbf2f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xbf62
sqrtsd %xmm0, %xmm0
jmp 0xbf67
movq $0x0, (%rbx)
jmp 0xbf8a
callq 0x3230
movsd %xmm0, (%rbx)
testl %r12d, %r12d
jle 0xbf8a
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0xbf72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x28(%rsp), %r14
movl $0x8, %edx
movq %rdi, %rbx
movq %r14, %rdi
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r15
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
vmovups %xmm0, (%rbx)
movb $0x0, (%r12)
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 0x8(%rsp), %rdi
movq %rax, %r14
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_O3/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 0x3046
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
testl %eax, %eax
js 0x2a75
movq (%rbx), %rdx
movl %eax, %ecx
incl %ecx
xorl %edi, %edi
xorl %r8d, %r8d
leaq -0x1(%rcx), %rsi
testq %r8, %r8
je 0x2a64
leal 0x1(%r8), %r9d
cmpq %r8, %rsi
leal -0x1(%r8), %r10d
cmovel %edi, %r9d
movl %r10d, (%rdx,%r8,8)
movl %r9d, 0x4(%rdx,%r8,8)
jmp 0x2a6d
movl %eax, (%rdx)
movl $0x1, 0x4(%rdx)
incq %r8
cmpq %r8, %rcx
jne 0x2a45
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3af9
movq %rbx, %rdi
movl %esi, %ebp
callq 0x3b0a
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x3b4c
movq 0x18(%rbx), %rdi
movslq %r14d, %rcx
movslq %ebp, %rsi
movq 0x38(%rbx), %rax
leaq (%rcx,%rcx,2), %rdx
leaq (%rsi,%rsi,2), %r15
movl 0x8(%rdi,%rdx,4), %esi
movl %esi, (%rax,%r15,4)
cmpl %ecx, %esi
je 0x3ae6
leaq (%rax,%r15,4), %r12
incl %ebp
shlq $0x2, %r15
movq 0x38(%rbx), %rcx
movq %rbx, %rdi
movq %rbx, %rdx
addq %r15, %rcx
movq %rcx, %r8
callq 0x3cbe
cmpl $0x1, 0xa8(%rbx)
jne 0x3aad
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 0x3ab7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3a18
movq 0x38(%rbx), %rdx
movl (%r12), %esi
movq %rbx, %rdi
movq %rbx, %rcx
addq %r15, %rdx
callq 0x3d7c
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 0x3a73
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3bb4
incq 0xb0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq (%r15,%r15,2), %rcx
movl 0x8(%rax,%rcx,4), %r14d
cmpl %r15d, %r14d
je 0x3b96
movl %esi, %ebp
movq %rbx, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x3c0e
movq 0x18(%rbx), %rcx
movslq %r14d, %rax
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,4), %r14d
cmpl %ebp, %r14d
jne 0x3b73
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_O3/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
incl 0xa8(%rdi)
movslq %esi, %rax
movl %esi, %ebx
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)
leaq (%rax,%rax,2), %rdx
movq 0x18(%rdi), %rcx
movl 0x4(%rcx,%rdx,4), %ebp
cmpl %eax, %ebp
je 0x3c09
movq %rdi, %r14
movq %r14, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e02
movq 0x18(%r14), %rcx
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
movl 0x4(%rcx,%rax,4), %ebp
cmpl %ebx, %ebp
jne 0x3be9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq 0x18(%rdi), %rax
movq %rcx, %r13
movslq %esi, %rcx
movq %r8, (%rsp)
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %r12
movl %esi, %ebp
leaq (%rcx,%rcx,2), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x3d1e
leaq 0xc(,%rcx,4), %rbx
movl %r14d, %ebp
movq 0x18(%r15), %rax
movq %r15, %rdi
movl (%rax,%rbx), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
callq 0x3b4c
movq 0x18(%r12), %rax
incl %ebp
cmpl $0x0, (%rax,%rbx)
leaq 0xc(%rbx), %rbx
jg 0x3cf7
leal -0x1(%r14), %ecx
movl %ebp, 0x8(%r13)
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rdx
cmpl $0x0, (%rax,%rdx,4)
jle 0x3d64
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rbx
movq 0x18(%r15), %rax
movq %r15, %rdi
movl (%rax,%rbx), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
callq 0x3b4c
movq 0x18(%r12), %rax
decl %r14d
cmpl $0x0, -0xc(%rax,%rbx)
leaq -0xc(%rbx), %rbx
jg 0x3d3b
movq (%rsp), %rax
movl %r14d, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq 0x4(%rdx), %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl %eax, %esi
je 0x3dc5
movq %rax, %rcx
shlq $0x2, %rcx
movl %ebp, %r12d
subl %eax, %r12d
leaq (%rcx,%rcx,2), %r15
movq 0x18(%rbx), %rax
movq %rbx, %rdi
movl (%rax,%r15), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
callq 0x3bb4
addq $0xc, %r15
decl %r12d
jne 0x3da5
movslq 0x8(%r14), %rax
cmpl %eax, %ebp
je 0x3df9
movq %rax, %rcx
shlq $0x2, %rcx
subl %eax, %ebp
leaq (%rcx,%rcx,2), %r14
movq 0x18(%rbx), %rax
movq %rbx, %rdi
movl (%rax,%r14), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
callq 0x3bb4
addq $-0xc, %r14
incl %ebp
jne 0x3dda
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3549(%rip), %rdi      # 0x5fc8
leaq 0x16d7(%rip), %rsi      # 0x415d
movl $0x39, %edx
callq 0x2160
movq 0x3541(%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 0x2abe
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a1c
testb %al, %al
je 0x2af9
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x18, %edx
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
jmp 0x2110
movq 0x34c8(%rip), %r14      # 0x5fc8
leaq 0x1690(%rip), %rsi      # 0x4197
movl $0x5, %edx
movq %r14, %rdi
callq 0x2160
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2160
leaq 0x1673(%rip), %rsi      # 0x419d
movl $0xc, %edx
movq %rax, %rdi
callq 0x2160
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2b69
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 0x3464(%rip), %rdi      # 0x5ff0
testb %al, %al
cmovneq 0x3432(%rip), %rdi      # 0x5fc8
leaq 0x1625(%rip), %rcx      # 0x41c2
leaq 0x1606(%rip), %rsi      # 0x41aa
cmovneq %rcx, %rsi
xorb $0x1, %al
movzbl %al, %eax
leaq (%rax,%rax,8), %rdx
addq $0xe, %rdx
callq 0x2160
movq 0x33ff(%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_O3/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 0x2c3e
addq $0x10, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
jmp 0x2c59
movq 0x3383(%rip), %rbx      # 0x5fc8
leaq 0x1585(%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_O3/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 0x2daf
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rbx,%rdi)
jne 0x2d9d
addq %rbx, %rdi
xorl %ebp, %ebp
leaq 0x150e(%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 0x2d7f
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 0x2d60
cmpl $0x2, %r14d
je 0x2d53
cmpl $0x1, %r14d
jne 0x2d6d
movq %rax, %rdi
callq 0x21f0
movl %eax, (%rbx)
jmp 0x2d6d
movq %r13, %rdi
movq %rax, %rsi
callq 0x2120
jmp 0x2d6d
movq %rax, %rdi
callq 0x2190
movsd %xmm0, (%r15)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2200
incl %r14d
testq %rax, %rax
jne 0x2d35
incq %rbp
movq 0x8(%rsp), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x2, 0x20(%rbx,%rax)
je 0x2cdb
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3212(%rip), %rbx      # 0x5fc8
leaq 0x1414(%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_O3/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 0x13c1(%rip), %rsi      # 0x41e6
leaq 0x13c6(%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 0x2fb8
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2ac6
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e86
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x50(%rsp), %rdi
leaq 0x260(%rsp), %rsi
callq 0x2c8c
movq 0x3129(%rip), %rdi      # 0x5fc8
leaq 0x134d(%rip), %rsi      # 0x41f3
movl $0x38, %edx
callq 0x2160
leaq 0x260(%rsp), %rbx
movq 0x3109(%rip), %r14      # 0x5fc8
leaq 0x1366(%rip), %r15      # 0x422c
leaq 0x144e(%rip), %r12      # 0x431b
movq 0x3104(%rip), %r13      # 0x5fd8
leaq 0xf(%rsp), %rbp
movq %rbx, %rdi
callq 0x3050
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 0x2ed9
movabsq $0x300000003, %rcx      # imm = 0x300000003
btq %rax, %rcx
jae 0x2ed9
leaq 0x50(%rsp), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2f4f
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 0x2f89
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x2f89
movq %rax, %rbx
jmp 0x2f93
jmp 0x2f86
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2faf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f63(%rip), %r14      # 0x5fc8
leaq 0x11f4(%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 0x11e4(%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 0x11c0(%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 0x119f(%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 0x1178(%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 0x1150(%rip), %r15      # 0x42e3
movq 0x2e3e(%rip), %r12      # 0x5fd8
leaq 0x7(%rsp), %r13
leaq 0x10aa(%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 0x3200
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x322c
jmp 0x31a6
movq %rbx, %rdi
callq 0x344e
jmp 0x31a6
movq %rbx, %rdi
callq 0x242c
jmp 0x31a6
movq %rbx, %rdi
callq 0x333d
jmp 0x31a6
movq 0x2dc1(%rip), %rdi      # 0x5fc8
leaq 0x10f1(%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_O3/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 0x3278
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 0x3249
movq 0x2d39(%rip), %r14      # 0x5fc8
leaq 0x1087(%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_O3/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 0x3459
movq 0x2b53(%rip), %r14      # 0x5fc8
leaq 0xeda(%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