LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::time2mjd(long, int*, double*)
void time2mjd(time_t time,int* mjd,double* sod){
	double ep[6];
	const int mday[] = { /* # of days in a month */
	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31,
			31, 30, 31, 30, 31, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
			31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int days, sec, mon, day;

	/* leap year if year%4==0 in 1901-2099 */
	days = (int) (time / 86400);
	sec = (int) (time - (time_t) days * 86400);
	for (day = days % 1461, mon = 0; mon < 48; mon++) {
		if (day >= mday[mon])
			day -= mday[mon];
		else
			break;
	}
	ep[0] = 1970 + days / 1461 * 4 + mon / 12;
	ep[1] = mon % 12 + 1;
	ep[2] = day + 1;
	ep[3] = sec / 3600;
	ep[4] = sec % 3600 / 60;
	ep[5] = sec % 60;

	*mjd = md_julday((int)ep[0],(int)ep[1],(int)ep[2]);
	*sod = ep[3] * 3600.0 + ep[4] * 60.0 + ep[5];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rcx
movabsq $0x1845c8a0ce512957, %rdx # imm = 0x1845C8A0CE512957
movq %rdi, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rdx
sarq $0xd, %rax
addq %rdx, %rax
movslq %eax, %rdi
imulq $0x166db073, %rdi, %rsi # imm = 0x166DB073
movq %rsi, %rdx
shrq $0x3f, %rdx
sarq $0x27, %rsi
addl %edx, %esi
imull $0x5b5, %esi, %edx      # imm = 0x5B5
subl %edx, %edi
leaq 0x4dae5(%rip), %r9      # 0x6aba0
xorl %r8d, %r8d
movl %edi, %edx
subl (%r9), %edx
jl 0x1d0dc
incq %r8
addq $0x4, %r9
movl %edx, %edi
cmpq $0x30, %r8
jne 0x1d0c0
movl $0x30, %r8d
jmp 0x1d0de
movl %edi, %edx
imull $0xfffeae80, %eax, %eax # imm = 0xFFFEAE80
addl %eax, %ecx
movl %r8d, %eax
movl $0xaaaaaaab, %r9d       # imm = 0xAAAAAAAB
imulq %rax, %r9
shrq $0x23, %r9
leal (%r9,%rsi,4), %edi
addl $0x7b2, %edi            # imm = 0x7B2
shll $0x2, %r9d
leal (%r9,%r9,2), %eax
negl %eax
leal (%r8,%rax), %esi
incl %esi
movslq %ecx, %rax
imulq $-0x6e5d4c3b, %rax, %rcx # imm = 0x91A2B3C5
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %r8d
shrl $0x1f, %r8d
sarl $0xb, %ecx
addl %r8d, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x28(%rbp)
imull $0xe10, %ecx, %ecx      # imm = 0xE10
movl %eax, %r8d
subl %ecx, %r8d
movswl %r8w, %ecx
imull $0xffff8889, %ecx, %ecx # imm = 0xFFFF8889
shrl $0x10, %ecx
addl %r8d, %ecx
movzwl %cx, %ecx
movswl %cx, %r8d
shrl $0xf, %ecx
sarl $0x5, %r8d
addl %ecx, %r8d
movswl %r8w, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x20(%rbp)
incl %edx
imulq $-0x77777777, %rax, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %ecx
addl %r8d, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x1c8ec
movsd -0x20(%rbp), %xmm1
mulsd 0x4d705(%rip), %xmm1    # 0x6a8b8
movsd -0x28(%rbp), %xmm0
mulsd 0x4d700(%rip), %xmm0    # 0x6a8c0
movl %eax, (%r14)
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x1d209
movapd %xmm0, %xmm1
divsd 0x4d6dd(%rip), %xmm1    # 0x6a8d0
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 0x1d21f
movsd 0x4d6ba(%rip), %xmm1    # 0x6a8d0
callq 0x8850
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::fillobs(char*, int, int, double)
void fillobs(char* line,int nobs,int itemlen,double ver){
	int OFFSET = 0,len,i;
	char tmp[256];
	if(ver > 3.0)
		OFFSET = 3;
	len = len_trim(line);
	for(i = len;i < itemlen * nobs + OFFSET;i++)
		line[i] = ' ';
	line[itemlen * nobs + OFFSET] = '\0';
	for(i = 0;i < nobs;i++){
		memset(tmp,0,sizeof(char) * 256);
		substringEx(tmp,line + OFFSET + i * itemlen,0,itemlen - 2); // last is signal strength
		if(len_trim(tmp) == 0){
			line[itemlen * i + OFFSET + 1] = '0';
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edx, %ebx
movl %esi, %r15d
xorl %eax, %eax
ucomisd 0x4d69f(%rip), %xmm0    # 0x6a8e8
movq %rdi, %r14
seta %al
leal (%rax,%rax,2), %r12d
callq 0x1d2ee
movl %ebx, %r13d
imull %r15d, %r13d
addl %r12d, %r13d
cmpl %r13d, %eax
jge 0x1d282
movslq %eax, %rdi
addq %r14, %rdi
notl %eax
addl %r13d, %eax
incq %rax
movl $0x20, %esi
movq %rax, %rdx
callq 0x8390
movslq %r13d, %rax
movb $0x0, (%r14,%rax)
testl %r15d, %r15d
jle 0x1d2dc
movl %r12d, %eax
addq %rax, %r14
movslq %ebx, %r12
addl $-0x2, %ebx
movl %r15d, %r13d
leaq -0x130(%rbp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x8390
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x1d336
movq %r15, %rdi
callq 0x1d2ee
testl %eax, %eax
jne 0x1d2d4
movb $0x30, 0x1(%r14)
addq %r12, %r14
decq %r13
jne 0x1d2a5
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::pointer_string(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int pointer_string(int cnt,string string_array[],string str){
	int itr,idx = -1;
	for(itr = 0;itr < cnt;itr++){
		if(string_array[itr] == str){
			idx = itr;
			break;
		}
	}
	return idx;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edi, %edi
jle 0x1d4e6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rdx), %r12
movl %edi, %ebx
addq $0x8, %r15
xorl %r13d, %r13d
cmpq %r12, (%r15)
jne 0x1d4c2
testq %r12, %r12
je 0x1d4d5
movq (%r14), %rsi
movq -0x8(%r15), %rdi
movq %r12, %rdx
callq 0x8650
testl %eax, %eax
je 0x1d4d5
incq %r13
addq $0x20, %r15
cmpq %r13, %rbx
jne 0x1d4a5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1d4d8
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::pointer_charstr(int, int, char const*, char const*)
int pointer_charstr(int row, int col, const char* string_array, const char* string) {
	int i;
	const char* pStr = (const char*)string_array;
	for (i = 0; i < row; i++) {
		if (strcmp(pStr + i*col, string) == 0)
			break;
	}
	if (i == row)
		i = -1;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x1d52d
movq %rcx, %r14
movq %rdx, %r15
movl %edi, -0x2c(%rbp)
movl %edi, %r13d
movslq %esi, %rbx
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x8880
testl %eax, %eax
je 0x1d528
incq %r12
addq %rbx, %r15
cmpq %r12, %r13
jne 0x1d50b
movl %r13d, %r12d
movl -0x2c(%rbp), %edi
jmp 0x1d530
xorl %r12d, %r12d
cmpl %edi, %r12d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x8290
testl %eax, %eax
jle 0x1d57c
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb %bl, (%r14,%rcx)
je 0x1d57e
incq %rcx
cmpq %rcx, %rdx
jne 0x1d56a
movl %eax, %ecx
jmp 0x1d57e
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]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::left_justify_string(char*)
char* left_justify_string(char* string) {
	int p = 0;
	while (*(string + p) == ' ' || *(string + p) == '\n'
			|| *(string + p) == '\r')
		p++;
	return string + p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movabsq $0x100002400, %rcx      # imm = 0x100002400
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x1d5b2
btq %rdx, %rcx
jae 0x1d5b2
incq %rax
jmp 0x1d59e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::toUpper(char*)
char* toUpper(char* value) {
	int len = strlen((const char*)value);
	int i;
	for (i = 0; i < len; i++) {
		if (value[i] >= 'a' && value[i] <= 'z')
			value[i] -= 32;
	}
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8290
testl %eax, %eax
jle 0x1d5e7
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x1d5df
addb $-0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1d5cd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::toLower(char*)
char* toLower(char* value) {
	int len = strlen((const char*)value);
	int i;
	for (i = 0; i < len; i++) {
		if (value[i] >= 'A' && value[i] <= 'Z')
			value[i] += 32;
	}
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8290
testl %eax, %eax
jle 0x1d624
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x1d61c
orb $0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1d60a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::trim(char*)
char* trim(char* pStr) {
	int len = strlen(pStr);
	char* pIndex = pStr + len - 1;
	while (*pIndex == '\n' || *pIndex == '\r' || *pIndex == '\0'
			|| *pIndex == ' ') {
		*pIndex = '\0';
		if(pStr == pIndex)
			break;
		pIndex--;
	}
	return pStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8290
cltq
movabsq $0x100002401, %rcx      # imm = 0x100002401
movzbl -0x1(%rbx,%rax), %edx
cmpq $0x20, %rdx
ja 0x1d937
btq %rdx, %rcx
jae 0x1d937
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x1d91c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::split_string(bool, char*, char, char, char, int*, char*, int)
void split_string(bool lnoempty, char* string, char c_start, char c_end,
		char seperator, int* nword, char* keys, int len) {
	int i0 = 0, i1, ilast, i;
	char varword[1024];
	char* word = (char*)keys;
	i1 = len_trim(string) - 1;
	if (c_start != ' ')
		i0 = index_string(string, c_start);
	if (c_end != ' ')
		i1 = index_string(string, c_end);
	*nword = 0;
	if (i1 == -1 || i0 > i1)
		return;

	ilast = i0;
	if(string[i1] != seperator)
		string[i1 + 1] = seperator;
	string[i1 + 2] = '\0';

	for (i = i0; i < i1 + 2; i++) {
		if (string[i] == seperator) {
			if (i - 1 >= ilast) {
				substringEx(varword, string, ilast, i - ilast);
				strcpy(word+(*nword)*len, varword);
				(*nword)++;
			} else {
				if (!lnoempty) {
					strcpy(word+(*nword)*len, "  ");
					(*nword)++;
				}
			}
			ilast = i + 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %r9, -0x38(%rbp)
movl %r8d, %r14d
movl %ecx, %ebx
movl %edx, %r15d
movl %edi, -0x3c(%rbp)
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x1d2ee
movl %eax, %r12d
xorl %r13d, %r13d
cmpb $0x20, %r15b
je 0x1d98c
movsbl %r15b, %esi
movq -0x30(%rbp), %rdi
callq 0x1d54b
movl %eax, %r13d
cmpb $0x20, %bl
jne 0x1d996
decl %r12d
jmp 0x1d9a5
movsbl %bl, %esi
movq -0x30(%rbp), %rdi
callq 0x1d54b
movl %eax, %r12d
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
cmpl $-0x1, %r12d
sete %al
cmpl %r12d, %r13d
setg %cl
orb %al, %cl
movq -0x30(%rbp), %rdx
jne 0x1da74
movl 0x18(%rbp), %eax
movslq %r12d, %r12
cmpb %r14b, (%rdx,%r12)
je 0x1d9d9
movb %r14b, 0x1(%rdx,%r12)
movb $0x0, 0x2(%rdx,%r12)
addq $0x2, %r12
movslq %r13d, %rbx
cltq
movq %rax, -0x48(%rbp)
cmpb %r14b, (%rdx,%rbx)
jne 0x1da3a
movslq %r13d, %rax
cmpq %rax, %rbx
jle 0x1da3f
movl %ebx, %ecx
subl %r13d, %ecx
movl %r14d, %r15d
leaq -0x450(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movl %r13d, %edx
callq 0x1d336
movq -0x38(%rbp), %r13
movslq (%r13), %rdi
imulq -0x48(%rbp), %rdi
addq 0x10(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %r14d
callq 0x85c0
movq -0x30(%rbp), %rdx
jmp 0x1da61
incq %rbx
jmp 0x1da6b
cmpb $0x0, -0x3c(%rbp)
jne 0x1da65
movq -0x38(%rbp), %r13
movslq (%r13), %rax
imulq -0x48(%rbp), %rax
movq 0x10(%rbp), %rcx
movb $0x0, 0x2(%rcx,%rax)
movw $0x2020, (%rcx,%rax)    # imm = 0x2020
incl (%r13)
incq %rbx
movl %ebx, %r13d
cmpl %r12d, %ebx
jne 0x1d9ec
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x1dac1
movsd 0x4ce2f(%rip), %xmm1    # 0x6a8f0
je 0x1dacb
movsd 0x4ce2d(%rip), %xmm0    # 0x6a8f8
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd %xmm1, %xmm3
cmpnlesd 0x4ce18(%rip), %xmm3    # 0x6a900
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 0x8150
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd -0x38(%rbp), %xmm1
movsd 0x4bdeb(%rip), %xmm0    # 0x69920
subsd %xmm1, %xmm0
ucomisd 0x4cdc7(%rip), %xmm0    # 0x6a908
jb 0x1db49
sqrtsd %xmm0, %xmm0
jmp 0x1db4e
callq 0x84e0
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 0x8bf0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8bf0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x8bf0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8150
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x4bd4c(%rip), %xmm0    # 0x69920
subsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
addsd 0x10(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%r14), %xmm0
callq 0x8150
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]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x4c9b2(%rip), %xmm0    # 0x6a928
movsd %xmm0, -0x20(%rbp)
callq 0x8bf0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8150
movaps %xmm0, -0x20(%rbp)
movsd 0x4c98d(%rip), %xmm0    # 0x6a928
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x8bf0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x8150
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 0x4cae2(%rip), %xmm1    # 0x6aad0
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]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::transpose(double*, double*, int, int)
void transpose(double* in, double* out, int row, int col) {
	double* tmp = (double*)calloc(row * col,sizeof(double));
	int i, j;
	for(i = 0;i < row;i++)
		for(j = 0; j < col;j++)
			tmp[j * row  + i] = in[i * col + j];

	for(j = 0; j < col;j++)
		for(i = 0;i < row;i++)
			out[j * row + i] = tmp[j * row + i];
	free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
movl %ecx, %eax
imull %edx, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x8440
movq %rax, -0x30(%rbp)
movl %ebx, %r12d
movl %r13d, %r15d
testl %ebx, %ebx
jle 0x1e1c7
leaq (,%r15,8), %rax
leaq (,%r12,8), %rcx
xorl %edx, %edx
movq -0x30(%rbp), %rsi
testl %r13d, %r13d
jle 0x1e1b8
movq %rsi, %rdi
xorl %r8d, %r8d
movsd (%r14,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %r8
addq %rcx, %rdi
cmpq %r8, %r15
jne 0x1e1a3
incq %rdx
addq %rax, %r14
addq $0x8, %rsi
cmpq %r12, %rdx
jne 0x1e198
testl %r13d, %r13d
movq -0x38(%rbp), %r13
jle 0x1e201
shlq $0x3, %r12
xorl %r14d, %r14d
testl %ebx, %ebx
jle 0x1e1f9
movl %r14d, %eax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rax,8), %rsi
leaq (,%rax,8), %rdi
addq %r13, %rdi
movq %r12, %rdx
callq 0x84f0
addl %ebx, %r14d
decq %r15
jne 0x1e1d7
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x87a0
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x1e2c8
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 0x1e29e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1e2d1
sqrtsd %xmm0, %xmm0
jmp 0x1e2d6
movq $0x0, (%rbx)
jmp 0x1e2f9
callq 0x84e0
movsd %xmm0, (%rbx)
testl %r12d, %r12d
jle 0x1e2f9
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1e2e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::dot(int, double*, double*)
double dot(int n, double* v1, double* v2) {
	int i;
	double res;
	res = 0.0;
	for (i = 0; i < n; i++)
		res = res + v1[i] * v2[i];
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x1e330
movl %edi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm1
mulsd (%rdx,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x1e318
jmp 0x1e334
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::distance(int, double*, double*)
double distance(int n,double *v1,double* v2){
	int i;
	double* dx = (double*)calloc(n,sizeof(double)),dist;
	for(i = 0; i < n ;i++)
		dx[i] = v1[i] - v2[i];
	dist = sqrt(dot(n,dx,dx));
	free(dx);
	return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r14d
movslq %edi, %r13
movl $0x8, %esi
movq %r13, %rdi
callq 0x8440
movq %rax, %rbx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %r13d, %r13d
jle 0x1e3ab
movl %r14d, %eax
xorl %ecx, %ecx
movsd (%r12,%rcx,8), %xmm0
subsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1e372
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jle 0x1e3ab
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x1e396
ucomisd %xmm1, %xmm0
jb 0x1e3b7
sqrtsd %xmm0, %xmm0
jmp 0x1e3bc
callq 0x84e0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x87a0
movsd -0x30(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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, 38 - 19.0, mjd, sod);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rdi), %eax
leal -0x42(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1f3f1
movsd (%rdx), %xmm0
addsd 0x4b5b9(%rip), %xmm0    # 0x6a9a8
jmp 0x1f402
cmpl $0x52, %eax
jne 0x1f448
movsd (%rdx), %xmm0
addsd 0x4b4c6(%rip), %xmm0    # 0x6a8c8
movsd 0x4b4c6(%rip), %xmm1    # 0x6a8d0
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 0x1f448
decl %eax
movl %eax, (%rsi)
addsd 0x4b48c(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::sum(int*, int)
int sum(int array[], int ndim) {
	int i, sum0 = 0;

	for (i = 0; i < ndim; i++) {
		sum0 += array[i];
	}
	return sum0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x1f465
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
addl (%rdi,%rdx,4), %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x1f458
jmp 0x1f467
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::all(int*, int, int)
int all(int* vx,int n,int value){
	int i = 0,ret;
	ret = 1;
	for(i = 0;i < n;i++){
		if(vx[i] != value){
			ret = 0;
			break;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
testl %esi, %esi
jle 0x1f48b
movl %esi, %ecx
xorl %esi, %esi
cmpl %edx, (%rdi,%rsi,4)
jne 0x1f489
incq %rsi
cmpq %rsi, %rcx
jne 0x1f47a
jmp 0x1f48b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::chos(int, int, int*)
bool chos(int ndel, int imax, int* idel) {
	int i, ic;
	if (imax < ndel)
		return false;
	if (idel[0] == -1) {
		for (i = 0; i < ndel; i++)
			idel[i] = i;
		return true;
	} else {
		ic = ndel;
		while (ic > 0) {
			idel[ic - 1] = idel[ic - 1] + 1;
			if (idel[ic - 1] >= imax) {
				ic--;
				continue;
			}
			i = ic + 1;
			while (i <= ndel) {
				idel[i - 1] = idel[i - 2] + 1;
				if (idel[i - 1] >= imax) {
					ic--;
					break;
				}
				i++;
			}
			if (i > ndel)
				break;
		}
		if (ic <= 0)
			return false;
		else
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edi, %esi
jge 0x1f499
xorl %eax, %eax
jmp 0x1f50e
cmpl $-0x1, (%rdx)
je 0x1f4f9
testl %edi, %edi
jle 0x1f4f2
movl %edi, %eax
movl %edi, %ecx
movl %ecx, %edi
movl -0x4(%rdx,%rdi,4), %r8d
incl %r8d
movl %r8d, -0x4(%rdx,%rdi,4)
movq %rcx, %rdi
cmpl %esi, %r8d
jge 0x1f4e6
cmpq %rax, %rdi
jge 0x1f4f0
movl -0x4(%rdx,%rdi,4), %r8d
incl %r8d
movl %r8d, (%rdx,%rdi,4)
incq %rdi
cmpl %esi, %r8d
jl 0x1f4bd
movq %rcx, %rdi
decq %rdi
cmpl $0x1, %ecx
movq %rdi, %rcx
jg 0x1f4a6
jmp 0x1f4f2
leal -0x1(%rcx), %edi
cmpl $0x1, %ecx
jg 0x1f4a4
jmp 0x1f4f2
movl %ecx, %edi
testl %edi, %edi
setg %al
jmp 0x1f50e
movb $0x1, %al
testl %edi, %edi
jle 0x1f50e
movl %edi, %ecx
xorl %esi, %esi
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x1f503
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::ambslv(int, double*, double*, double*)
int ambslv(int ncad, double* q22, double* bias, double* disall) {
	/**********************************************
	 * parameter:
	 * 	input:  ncad          -- # of candidate ambiguities
	 * 		    q22           -- cofactor matrix
	 * 	output: bias          -- float / fixed ambiguity estimates
	 *          disall        -- norm of optimum & suboptimum solutions
	 */
	double* F = (double*) calloc(2 * ncad, sizeof(double));
	double* s = (double*) calloc(2, sizeof(double));
	double dump;
	int info  = 0;
	if (ncad > 1) {
		if(!(info = lambda(ncad, 2, bias, q22, F, s))){
			if (s[0] < s[1]) {
				memcpy(bias, F, sizeof(double) * ncad);
				disall[0] = s[0];
				disall[1] = s[1];
			} else {
				memcpy(bias, F + ncad, sizeof(double) * ncad);
				disall[0] = s[1];
				disall[1] = s[0];
			}
		}
	} else {
		dump = bias[0];
		bias[0] = NINT(bias[0]) * 1.0;
		dump = bias[0] - dump;
		disall[0] = dump * dump / q22[0];
		dump = 1.0 - fabs(dump);
		disall[1] = dump * dump / q22[0];
	}
	free(F);
	free(s);
	return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebx
leal (%rbx,%rbx), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x8440
movq %rax, %r15
movl $0x2, %edi
movl $0x8, %esi
callq 0x8440
cmpl $0x2, %ebx
jl 0x1f5ce
movq %r14, -0x40(%rbp)
movl %ebx, %edi
movl $0x2, %esi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rax, %r9
movq %r12, %r14
movq %rax, %r12
callq 0x32760
movl %eax, %r13d
testl %eax, %eax
movq %r15, %rsi
jne 0x1f648
movsd (%r12), %xmm0
movq %r12, -0x48(%rbp)
movsd 0x8(%r12), %xmm1
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
ucomisd %xmm0, %xmm1
movl %ebx, %edx
jbe 0x1f66a
shlq $0x3, %rdx
movq %r14, %rdi
movq %rsi, %r15
callq 0x84f0
movq -0x40(%rbp), %r14
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x30(%rbp), %xmm0
jmp 0x1f638
movq %rax, -0x48(%rbp)
movsd (%r12), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x4b4f4(%rip), %rcx     # 0x6aae0
movsd (%rcx,%rax,8), %xmm1
addsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movlpd %xmm1, (%r12)
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
divsd (%r13), %xmm0
movsd %xmm0, (%r14)
andpd 0x4a30e(%rip), %xmm1    # 0x69930
movsd 0x4a2f6(%rip), %xmm0    # 0x69920
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
divsd (%r13), %xmm0
movsd %xmm0, 0x8(%r14)
xorl %r13d, %r13d
movq %r15, %rsi
movq -0x48(%rbp), %r12
movq %rsi, %rdi
callq 0x87a0
movq %r12, %rdi
callq 0x87a0
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
leaq (%rsi,%rdx,8), %rsi
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x84f0
movq -0x40(%rbp), %r14
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x38(%rbp), %xmm0
jmp 0x1f638
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::pointer_int(int, int*, int)
int pointer_int(int n,int* array,int i){
	int k;
	for(k = 0;k<n;k++){
		if(array[k] == i)
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x1f8c0
movl %edi, %eax
xorl %ecx, %ecx
cmpl %edx, (%rsi,%rcx,4)
je 0x1f8c4
incq %rcx
cmpq %rcx, %rax
jne 0x1f8b3
xorl %eax, %eax
jmp 0x1f8c9
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::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 0x20113
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 0x200ec
incq %rsi
testq %rdi, %rdi
jne 0x200db
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::genAode(char, int, double, double, int, bamboo::GPSEPH*)
int genAode(char csys,int mjd,double sod,double toe,int inade,GPSEPH* eph){
	int ret = -1;
	if(csys == 'G')
		ret = inade;
	else if(csys == 'R'){
		ret = NINT(fmod(sod + 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);
	}
	return ret;
}

// Assembly:
cmpl $0x46, %edi
jg 0x20839
cmpl $0x43, %edi
je 0x2088c
cmpl $0x45, %edi
je 0x20889
jmp 0x20884
cmpl $0x47, %edi
je 0x20889
cmpl $0x52, %edi
jne 0x20884
pushq %rbp
movq %rsp, %rbp
addsd 0x4a261(%rip), %xmm0    # 0x6aab0
movsd 0x4a079(%rip), %xmm1    # 0x6a8d0
callq 0x8850
divsd 0x4a254(%rip), %xmm0    # 0x6aab8
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x4a268(%rip), %rcx     # 0x6aae0
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %edx
popq %rbp
jmp 0x20889
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %eax
retq
movq %rcx, %rdi
jmp 0x20116
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::getNoZeroCount(double*, int)
int getNoZeroCount(double* xl,int n){
	int it,ret = 0;
	for(it = 0;it < n;it++)
		if(xl[it] != 0.0)
			ret++;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x2091f
movl %esi, %ecx
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rdi,%rdx,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rsi
subl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x20904
jmp 0x20921
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::excludeAnnoValue(char*, char const*)
void excludeAnnoValue(char* value,const char* in){
	int num = 0,lstart = false;
	const char* ptr = in;
	while(*ptr != '\0'){
		if(lstart == false && (*ptr == ' ' || *ptr == '\n' || *ptr == '\t')){
			++ptr;
			continue;
		}
		lstart = true;
		if(*ptr != '#' && *ptr != '!'){
			value[num++] = *ptr;
			++ptr;
		}else
			break;
	}
	value[num++] = '\0';
	trim(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x2099a
xorl %eax, %eax
movb $0x1, %r9b
movabsq $0x100000600, %rdi      # imm = 0x100000600
movabsq $0xa00000000, %r8       # imm = 0xA00000000
xorl %edx, %edx
incq %rsi
movzbl %cl, %r10d
testb $0x1, %r9b
je 0x20973
cmpb $0x23, %cl
ja 0x2097d
btq %r10, %rdi
jae 0x20990
movb (%rsi), %cl
incq %rsi
movb $0x1, %r9b
testb %cl, %cl
jne 0x20950
jmp 0x20996
orl $0x2, %r10d
cmpl $0x23, %r10d
je 0x20996
incl %edx
movb %cl, (%rbx,%rax)
incq %rax
movb (%rsi), %cl
xorl %r9d, %r9d
testb %cl, %cl
jne 0x2094d
jmp 0x2099c
btq %r10, %r8
jae 0x2097d
movl %eax, %edx
jmp 0x2099c
xorl %edx, %edx
movslq %edx, %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8290
cltq
movabsq $0x100002401, %rcx      # imm = 0x100002401
movzbl -0x1(%rbx,%rax), %edx
cmpq $0x20, %rdx
ja 0x209d2
btq %rdx, %rcx
jae 0x209d2
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x209b7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::zipJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string zipJson(string json){
	string zipStr = "";
	int isize = 0,jsize = json.size();
	char *zipPtr = new char[jsize];
	const char *ptr = json.c_str();
	memset(zipPtr,0,sizeof(char) * jsize);
	while(ptr - json.c_str() < json.size()){
		if(*ptr == ' ' || *ptr == '\t' || *ptr == '\n'){
			++ptr;
			continue;
		}
		zipPtr[isize++] = *ptr;
		++ptr;
	}
	zipStr = string(zipPtr);
	delete[] zipPtr;
	return zipStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x49bf3(%rip), %rdx     # 0x6a5f5
movq %rdx, %rsi
callq 0x1100a
movq 0x8(%r15), %r13
movslq %r13d, %r12
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x8040
movq %rax, %r14
movq (%r15), %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8390
testq %r13, %r13
je 0x20a82
movq %r15, %rax
negq %rax
xorl %ecx, %ecx
movabsq $0x100000600, %rdx      # imm = 0x100000600
leaq (%rax,%r15), %rsi
incq %r15
movzbl -0x1(%r15), %edi
cmpq $0x20, %rdi
ja 0x20a73
btq %rdi, %rdx
jae 0x20a73
incq %r15
incq %rsi
cmpq %r13, %rsi
jb 0x20a55
jmp 0x20a82
movb %dil, (%r14,%rcx)
incq %rcx
incq %rsi
cmpq %r13, %rsi
jb 0x20a4e
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x8290
movq %r14, %rdx
addq %rax, %rdx
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x1100a
leaq -0x50(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x20ac1
callq 0x85d0
movq %r14, %rdi
callq 0x8820
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20add
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x20aee
callq 0x85d0
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::~Log()
Log::~Log(){
	map<string, LogItem*>::iterator itr;
	itr = this->mapOut.begin();
	while(itr != mapOut.end()){
		(*(*itr).second).of->flush();
		(*(*itr).second).of->close();
		delete (*itr).second->of;
		delete (*itr).second;
		itr = mapOut.erase(itr);
	}
	def_destroylock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x20e17
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x8450
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x8890
movq 0x40(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x20df4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x40(%r14), %rdi
callq 0x85d0
movq %r14, %rdi
callq 0x8460
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200a
movq %r15, %r14
cmpq %r12, %r15
jne 0x20dc3
leaq 0x60(%rbx), %rdi
callq 0x8750
leaq 0x30(%rbx), %rdi
callq 0x21c6c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21cfa
movq %rax, %rdi
callq 0x1039a
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_openLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_openLog(string filName) {
	map<string, LogItem*>::iterator itr;
	itr = mapOut.find(string(filName));
	if (itr != mapOut.end()) {
		cout << "***WARINING(m_openLog):existing the same file " << filName
				<< endl;
		return;
	}
	ofstream* out = new ofstream;
	LogItem* item = new LogItem;
	item->of = out;
	out->open(filName.c_str(), ios::out);
	if (!(*out)) {
		cout << "cant create logger file " << filName << ",please the directory is exist!" << endl;
		exit(1);
	}
	def_lock(&_lock);
	this->mapOut.insert(pair<string, LogItem*>(filName, item));
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x111e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2204a
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x20e94
callq 0x85d0
leaq 0x8(%r14), %rax
cmpq %rax, %r15
je 0x20ef6
movq 0x6d12c(%rip), %r14     # 0x8dfd0
leaq 0x4a5d5(%rip), %rsi     # 0x6b480
movl $0x2e, %edx
movq %r14, %rdi
callq 0x8720
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x8720
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8600
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x8450
jmp 0x20fa6
movl $0x200, %edi            # imm = 0x200
callq 0x8640
movq %rax, %r12
movq %rax, %rdi
callq 0x8ae0
movl $0x18, %edi
callq 0x8640
movq %rax, %r15
movq $0x0, (%rax)
movq $0x15180, 0x10(%rax)    # imm = 0x15180
leaq 0x8(%rax), %rdi
callq 0x85b0
movq %r12, (%r15)
movq (%rbx), %rsi
movq %r12, %rdi
movl $0x10, %edx
callq 0x8090
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r12,%rax)
jne 0x20fb5
leaq 0x60(%r14), %r12
movq %r12, %rdi
callq 0x8900
leaq -0x50(%rbp), %r13
leaq -0x40(%rbp), %rax
movq %rax, (%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x111e0
movq %r15, 0x20(%r13)
movq %r14, %rdi
movq %r13, %rsi
callq 0x220e8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x20f9e
callq 0x85d0
movq %r12, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6d014(%rip), %rdi     # 0x8dfd0
leaq 0x4a4ec(%rip), %rsi     # 0x6b4af
callq 0x8620
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
leaq 0x4a4ee(%rip), %rsi     # 0x6b4c8
movq %rax, %rdi
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
jne 0x2101a
jmp 0x2101f
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2101a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2101f
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_lexist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Log::m_lexist(string filName){
	map<string, LogItem*>::iterator itr;
	itr = mapOut.find(string(filName));
	if (itr != mapOut.end())
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x111e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2204a
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x21281
callq 0x85d0
addq $0x8, %rbx
cmpq %rbx, %r14
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x212a7
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_chkUpdate(char const*, bamboo::LogItem*)
void Log::m_chkUpdate(const char* fil,LogItem* item){
	// check whether update the log file when the interval is coming
	if(item->lupd){
		char filname[1024] = {0};
		time_t now = time(NULL);
		struct tm* ptr;
		ptr = localtime(&now);
		int mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday),gwk;
		double sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec,gsow;
		mjd2wksow(mjd,sod,&gwk,&gsow);
		if(now - item->lastActive > item->interval){
			item->lastActive = (now / item->interval) * item->interval;
			item->of->flush();
			item->of->close();
			delete item->of;
			sprintf(filname,"%s.%04d%02d%02d-%02d:%02d:%02d",fil,ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday,ptr->tm_hour,
					ptr->tm_min,ptr->tm_sec);
			rename(fil,filname);
			item->of = new ofstream;
			item->of->open(fil, ios::out);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
cmpl $0x0, 0x14(%rdx)
je 0x2140f
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x440(%rbp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x8390
xorl %edi, %edi
callq 0x85b0
leaq -0x38(%rbp), %r12
movq %rax, (%r12)
movq %r12, %rdi
callq 0x84a0
movq %rax, %r15
movl $0x76c, %edi            # imm = 0x76C
addl 0x14(%rax), %edi
movl 0xc(%rax), %edx
movl 0x10(%rax), %esi
incl %esi
callq 0x1c8ec
cvtsi2sdl 0x8(%r15), %xmm1
cvtsi2sdl 0x4(%r15), %xmm0
mulsd 0x49590(%rip), %xmm0    # 0x6a8b8
mulsd 0x49590(%rip), %xmm1    # 0x6a8c0
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl (%r15), %xmm0
addsd %xmm1, %xmm0
leaq -0x24(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl %eax, %edi
callq 0x1cf30
movq (%r12), %rcx
movq %rcx, %rax
subq 0x8(%r14), %rax
movslq 0x10(%r14), %rsi
cmpq %rsi, %rax
jle 0x2140f
movq %rcx, %rax
cqto
idivq %rsi
subq %rdx, %rcx
movq %rcx, 0x8(%r14)
movq (%r14), %rdi
callq 0x8450
movq (%r14), %rdi
callq 0x8890
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21394
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x76c, %ecx            # imm = 0x76C
addl 0x14(%r15), %ecx
movl 0x10(%r15), %r8d
incl %r8d
movl 0xc(%r15), %r9d
movl 0x8(%r15), %r10d
movl (%r15), %r11d
movl 0x4(%r15), %r12d
subq $0x8, %rsp
leaq 0x4a16a(%rip), %rsi     # 0x6b528
leaq -0x440(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
pushq %r11
pushq %r12
pushq %r10
callq 0x8120
addq $0x20, %rsp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x83f0
movl $0x200, %edi            # imm = 0x200
callq 0x8640
movq %rax, %r15
movq %rax, %rdi
callq 0x8ae0
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x8090
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_closeLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_closeLog(string filname){
	map<string, LogItem*>::iterator itr;
	itr = mapOut.find(string(filname));
	def_lock(&_lock);
	if (itr != mapOut.end()) {
		(*(*itr).second).of->flush();
		(*(*itr).second).of->close();
		delete (*itr).second->of;
		delete (*itr).second;
		mapOut.erase(itr);
	}
	map<string,map<string,unsigned int> >::iterator iTtr;
	iTtr = mtimeLog.find(filname);
	if(iTtr != mtimeLog.end()){
		mtimeLog.erase(iTtr);
	}
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x111e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2204a
movq %rax, %r12
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x216dd
callq 0x85d0
leaq 0x60(%rbx), %r15
movq %r15, %rdi
callq 0x8900
leaq 0x8(%rbx), %rax
cmpq %rax, %r12
je 0x21737
movq 0x40(%r12), %rax
movq (%rax), %rdi
callq 0x8450
movq 0x40(%r12), %rax
movq (%rax), %rdi
callq 0x8890
movq 0x40(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x21727
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x40(%r12), %rdi
callq 0x85d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200a
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x222da
addq $0x38, %rbx
cmpq %rbx, %rax
je 0x2175a
movq %r12, %rdi
movq %rax, %rsi
callq 0x22378
movq %r15, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x21782
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_tmeTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_tmeTag(string filName,string tag){
	unsigned int tt = tickget();
	map<string,map<string,unsigned int> >::iterator itr;
	def_lock(&_lock);
	itr = mtimeLog.find(filName);
	if(itr == mtimeLog.end()){
		map<string,unsigned int> tmp;
		tmp.insert(make_pair(tag, tt));
		mtimeLog.insert(make_pair(filName,tmp));
	}
	else
		(*itr).second.insert(make_pair(tag, tt));
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
callq 0x4fece
movl %eax, -0x2c(%rbp)
leaq 0x60(%r12), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8900
leaq 0x30(%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x222da
addq $0x38, %r12
cmpq %r12, %rax
je 0x2182c
movq %rax, %rbx
addq $0x40, %rbx
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x111e0
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x223bc
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x218e7
callq 0x85d0
jmp 0x218e7
movq %r15, %r12
movl -0x2c(%rbp), %r15d
leaq -0xb0(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x78(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x111e0
leaq -0x88(%rbp), %rsi
movl %r15d, 0x20(%rsi)
leaq -0xb8(%rbp), %rdi
callq 0x223bc
movq -0x88(%rbp), %rdi
movq %rbx, %r15
cmpq %rbx, %rdi
je 0x2189c
callq 0x85d0
leaq -0x88(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
movq %r14, %rsi
callq 0x21d8e
leaq -0x88(%rbp), %rsi
movq %r12, %rdi
callq 0x225ac
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x21bd8
movq -0x20(%rbx), %rdi
cmpq %r15, %rdi
je 0x218db
callq 0x85d0
leaq -0xb8(%rbp), %rdi
callq 0x21bd8
movq -0x38(%rbp), %rdi
callq 0x84b0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x21bac
jmp 0x21931
jmp 0x2192e
movq %rbx, %rcx
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %rcx, %rdi
je 0x21931
callq 0x85d0
jmp 0x21931
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x21bd8
movq %rbx, %rdi
callq 0x8b30
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x2193d
callq 0x85d0
jmp 0x2193d
nop