LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::mjd2time(int, double)
time_t mjd2time(int mjd,double sod){
    const int doy[]={1,32,60,91,121,152,182,213,244,274,305,335};
    time_t time= 0;
    int days,sec,year,mon,day,hour,min;
    double dsec;
    mjd2date(mjd,sod,&year,&mon,&day,&hour,&min,&dsec);
    if (year<1970||2099<year||mon<1||12<mon) return time;

    /* leap year if year%4==0 in 1901-2099 */
    days=(year-1970)*365+(year-1969)/4+doy[mon-1]+day-2+(year%4==0&&mon>=3?1:0);
    sec=(int)floor(dsec);
    time = (time_t)days * 86400 + hour * 3600 + min * 60 + sec;
    return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq -0x28(%rbp), %rax
movq %rax, (%rsp)
leaq -0x30(%rbp), %rbx
leaq -0x2c(%rbp), %r14
leaq -0x1c(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x14(%rbp), %r9
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1d2d2
movl (%rbx), %eax
leal -0x834(%rax), %ecx
cmpl $0xffffff7e, %ecx       # imm = 0xFFFFFF7E
setb %dl
movl (%r14), %ecx
leal -0xd(%rcx), %esi
cmpl $-0xc, %esi
setb %sil
orb %dl, %sil
je 0x1d659
xorl %eax, %eax
jmp 0x1d6ce
imull $0x16d, %eax, %edx      # imm = 0x16D
leal -0x7b1(%rax), %esi
shrl $0x2, %esi
leal -0x1(%rcx), %edi
leaq 0x4d4fe(%rip), %r8      # 0x6ab70
movl -0x1c(%rbp), %r9d
testb $0x3, %al
sete %al
cmpl $0x3, %ecx
setge %cl
andb %al, %cl
movzbl %cl, %eax
addl %edx, %esi
addl %eax, %esi
addl (%r8,%rdi,4), %esi
leal (%r9,%rsi), %ebx
addl $0xfff50734, %ebx       # imm = 0xFFF50734
movsd -0x28(%rbp), %xmm0
callq 0x8ad0
cvttsd2si %xmm0, %eax
movslq %ebx, %rcx
imulq $0x15180, %rcx, %rcx    # imm = 0x15180
movslq -0x18(%rbp), %rdx
imulq $0xe10, %rdx, %rdx      # imm = 0xE10
movslq -0x14(%rbp), %rsi
imulq $0x3c, %rsi, %rsi
cltq
addq %rdx, %rax
addq %rsi, %rax
addq %rcx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d471(%rip), %r9      # 0x6aba0
xorl %r8d, %r8d
movl %edi, %edx
subl (%r9), %edx
jl 0x1d750
incq %r8
addq $0x4, %r9
movl %edx, %edi
cmpq $0x30, %r8
jne 0x1d734
movl $0x30, %r8d
jmp 0x1d752
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
movslq %r8d, %rcx
imulq $-0x77777777, %rcx, %r8 # imm = 0x88888889
shrq $0x20, %r8
addl %r8d, %ecx
movl %ecx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %ecx
addl %r8d, %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 0x1cf58
movsd -0x20(%rbp), %xmm1
mulsd 0x4d098(%rip), %xmm1    # 0x6a8b8
movsd -0x28(%rbp), %xmm0
mulsd 0x4d093(%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_O1/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 0x1d876
movapd %xmm0, %xmm1
divsd 0x4d070(%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 0x1d88c
movsd 0x4d04d(%rip), %xmm1    # 0x6a8d0
callq 0x8860
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d032(%rip), %xmm0    # 0x6a8e8
movq %rdi, %r14
seta %al
leal (%rax,%rax,2), %r12d
callq 0x1d95b
movl %ebx, %r13d
imull %r15d, %r13d
addl %r12d, %r13d
cmpl %r13d, %eax
jge 0x1d8ef
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 0x1d949
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 0x1d9a3
movq %r15, %rdi
callq 0x1d95b
testl %eax, %eax
jne 0x1d941
movb $0x30, 0x1(%r14)
addq %r12, %r14
decq %r13
jne 0x1d912
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1db2b
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
movq (%r15), %rdx
cmpq %r12, %rdx
jne 0x1db07
testq %rdx, %rdx
je 0x1db1a
movq (%r14), %rsi
movq -0x8(%r15), %rdi
callq 0x8650
testl %eax, %eax
je 0x1db1a
incq %r13
addq $0x20, %r15
cmpq %r13, %rbx
jne 0x1daea
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1db1d
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_O1/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 0x1db72
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 0x8890
testl %eax, %eax
je 0x1db6d
incq %r12
addq %rbx, %r15
cmpq %r12, %r13
jne 0x1db50
movl %r13d, %r12d
movl -0x2c(%rbp), %edi
jmp 0x1db75
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_O1/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 0x1dbc1
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb %bl, (%r14,%rcx)
je 0x1dbc3
incq %rcx
cmpq %rcx, %rdx
jne 0x1dbaf
movl %eax, %ecx
jmp 0x1dbc3
xorl %ecx, %ecx
cmpl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]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 0x1dbf7
btq %rdx, %rcx
jae 0x1dbf7
incq %rax
jmp 0x1dbe3
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dc2c
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x1dc24
addb $-0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1dc12
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dc69
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x1dc61
orb $0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1dc4f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1df81
btq %rdx, %rcx
jae 0x1df81
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x1df66
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movl %edx, %ebx
movl %edi, -0x3c(%rbp)
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x1d95b
movl %eax, %r12d
xorl %r13d, %r13d
cmpb $0x20, %bl
je 0x1dfd4
movsbl %bl, %esi
movq -0x30(%rbp), %rdi
callq 0x1db90
movl %eax, %r13d
cmpb $0x20, %r15b
jne 0x1dfdf
decl %r12d
jmp 0x1dfef
movsbl %r15b, %esi
movq -0x30(%rbp), %rdi
callq 0x1db90
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 0x1e0c3
movslq %r12d, %rbx
cmpb %r14b, (%rdx,%rbx)
je 0x1e020
movb %r14b, 0x1(%rdx,%rbx)
movb $0x0, 0x2(%rdx,%rbx)
addq $0x2, %rbx
cmpl %ebx, %r13d
jge 0x1e0c3
movslq %r13d, %r12
movslq 0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpb %r14b, (%rdx,%r12)
jne 0x1e0b7
movslq %r13d, %rax
cmpq %rax, %r12
jle 0x1e08c
movl %r12d, %ecx
subl %r13d, %ecx
movl %r14d, %r15d
leaq -0x450(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movl %r13d, %edx
callq 0x1d9a3
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 0x1e0ae
cmpb $0x0, -0x3c(%rbp)
jne 0x1e0b2
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)
leal 0x1(%r12), %r13d
incq %r12
cmpl %r12d, %ebx
jne 0x1e03d
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e110
movsd 0x4c7e0(%rip), %xmm1    # 0x6a8f0
je 0x1e11a
movsd 0x4c7de(%rip), %xmm0    # 0x6a8f8
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd %xmm1, %xmm3
cmpnlesd 0x4c7c9(%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 0x4b79c(%rip), %xmm0    # 0x69920
subsd %xmm1, %xmm0
ucomisd 0x4c778(%rip), %xmm0    # 0x6a908
jb 0x1e198
sqrtsd %xmm0, %xmm0
jmp 0x1e19d
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 0x8c00
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8c00
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x8c00
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8150
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x4b6fd(%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_O1/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 0x4c371(%rip), %xmm0    # 0x6a928
movsd %xmm0, -0x20(%rbp)
callq 0x8c00
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8150
movaps %xmm0, -0x20(%rbp)
movsd 0x4c34c(%rip), %xmm0    # 0x6a928
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x8c00
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 0x4c4a1(%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_O1/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 %r13d, %r15d
movl %ebx, %r12d
testl %ebx, %ebx
jle 0x1e801
leaq (,%r15,8), %rax
leaq (,%r12,8), %rcx
xorl %edx, %edx
movq -0x30(%rbp), %rsi
testl %r13d, %r13d
jle 0x1e7f2
movq %rsi, %rdi
xorl %r8d, %r8d
movsd (%r14,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %r8
addq %rcx, %rdi
cmpq %r8, %r15
jne 0x1e7dd
incq %rdx
addq %rax, %r14
addq $0x8, %rsi
cmpq %r12, %rdx
jne 0x1e7d2
testl %r13d, %r13d
movq -0x38(%rbp), %r13
jle 0x1e83b
shlq $0x3, %r12
xorl %r14d, %r14d
testl %ebx, %ebx
jle 0x1e833
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 0x1e811
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
movq $0x0, (%rcx)
movl %edi, %r13d
testl %edi, %edi
jle 0x1e8f2
movsd (%rbx), %xmm0
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %rax
cmpq %rax, %r13
jne 0x1e8d8
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1e906
sqrtsd %xmm0, %xmm0
jmp 0x1e90b
callq 0x84e0
movsd %xmm0, (%rbx)
testl %r12d, %r12d
jle 0x1e92e
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1e916
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]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 0x1e965
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 0x1e94d
jmp 0x1e969
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %r14d, %eax
testl %r13d, %r13d
jle 0x1e9b8
xorl %ecx, %ecx
movsd (%r12,%rcx,8), %xmm0
subsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1e99f
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jle 0x1e9dc
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x1e9c7
ucomisd %xmm1, %xmm0
jb 0x1e9e8
sqrtsd %xmm0, %xmm0
jmp 0x1e9ed
callq 0x84e0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x87b0
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_O1/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 0x1fa26
movsd (%rdx), %xmm0
addsd 0x4af84(%rip), %xmm0    # 0x6a9a8
jmp 0x1fa37
cmpl $0x52, %eax
jne 0x1fa81
movsd (%rdx), %xmm0
addsd 0x4ae91(%rip), %xmm0    # 0x6a8c8
movsd 0x4ae91(%rip), %xmm1    # 0x6a8d0
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addl (%rsi), %eax
movsd %xmm0, (%rdx)
movl %eax, (%rsi)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1fa81
decl %eax
movl %eax, (%rsi)
addsd 0x4ae53(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fa9e
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
addl (%rdi,%rdx,4), %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x1fa91
jmp 0x1faa0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fac4
movl %esi, %ecx
xorl %esi, %esi
cmpl %edx, (%rdi,%rsi,4)
jne 0x1fac2
incq %rsi
cmpq %rsi, %rcx
jne 0x1fab3
jmp 0x1fac4
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fad5
xorl %eax, %eax
jmp 0x1fb65
cmpl $-0x1, (%rdx)
je 0x1fb50
testl %edi, %edi
jle 0x1face
movl %edi, %ecx
movl %edi, %eax
movslq %eax, %r8
movl -0x4(%rdx,%r8,4), %r9d
incl %r9d
movl %r9d, -0x4(%rdx,%r8,4)
cmpl %esi, %r9d
jge 0x1fb2b
cmpl %edi, %eax
movl %edi, %r9d
cmovgl %eax, %r9d
cmpq %r8, %r9
je 0x1fb39
leaq 0x1(%r8), %r10
movl -0x4(%rdx,%r8,4), %r11d
incl %r11d
movl %r11d, (%rdx,%r8,4)
movq %r10, %r8
cmpl %esi, %r11d
jl 0x1fb00
decq %r10
cmpq %rcx, %r10
setl %r8b
decl %eax
jmp 0x1fb40
leal -0x1(%rax), %r8d
cmpl $0x1, %eax
movl %r8d, %eax
jg 0x1fae2
jmp 0x1fb49
cmpq %rcx, %r8
setl %r8b
testb %r8b, %r8b
je 0x1fb49
testl %eax, %eax
jg 0x1fae2
testl %eax, %eax
setg %al
jmp 0x1fb65
movb $0x1, %al
testl %edi, %edi
jle 0x1fb65
movl %edi, %ecx
xorl %esi, %esi
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x1fb5a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fc25
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 0x32d4c
movl %eax, %r13d
testl %eax, %eax
movq %r15, %rsi
jne 0x1fc9f
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 0x1fcc1
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 0x1fc8f
movq %rax, -0x48(%rbp)
movsd (%r12), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x4ae9d(%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 0x49cb7(%rip), %xmm1    # 0x69930
movsd 0x49c9f(%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 0x87b0
movq %r12, %rdi
callq 0x87b0
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 0x1fc8f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ff17
movl %edi, %eax
xorl %ecx, %ecx
cmpl %edx, (%rsi,%rcx,4)
je 0x1ff1b
incq %rcx
cmpq %rcx, %rax
jne 0x1ff0a
xorl %eax, %eax
jmp 0x1ff20
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2076a
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 0x20743
incq %rsi
testq %rdi, %rdi
jne 0x20732
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20ea2
cmpl $0x43, %edi
je 0x20ef5
cmpl $0x45, %edi
je 0x20ef2
jmp 0x20eed
cmpl $0x47, %edi
je 0x20ef2
cmpl $0x52, %edi
jne 0x20eed
pushq %rbp
movq %rsp, %rbp
addsd 0x49bf8(%rip), %xmm0    # 0x6aab0
movsd 0x49a10(%rip), %xmm1    # 0x6a8d0
callq 0x8860
divsd 0x49beb(%rip), %xmm0    # 0x6aab8
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x49bff(%rip), %rcx     # 0x6aae0
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %edx
popq %rbp
jmp 0x20ef2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %eax
retq
movq %rcx, %rdi
jmp 0x2076d
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::bdsCodeCorbyElv(int, double, double*)
void bdsCodeCorbyElv(int Prn, double elvRad, double* codeCor){
	int i = 0, j = 0;
	static double coef[14][3][3] = {
		{ { 1.0211, -0.6213, 0.2708 }, { 1.2526, -0.0896,-0.1790 }, { 1.3200, -1.1985, 0.5211 } },
		{ { 2.0465, -2.2363, 0.9862 }, { 0.5262, 0.2255, -0.1576 }, { -0.2278, 1.3401,-0.6411 } },
		{ { 1.2494, -1.0582, 0.5139 }, { 1.1609, -0.7834, 0.2694 }, { 1.4482, -1.2945, 0.3900 } },
		{ { 1.1879, -0.9541, 0.3953 }, { 0.1531, 0.8377, -0.4189 }, { 0.9770, -0.9244, 0.3965 } },
		{ { 2.1465, -2.4363, 0.9862 }, { 0.5294, -0.0964,-0.0198 }, { 0.2678, -0.2956, 0.2237 } },
		{ { 1.5271, -1.4497, 0.6116 }, { 0.1531, 0.8377, -0.4087 }, { 0.2678, -0.2956, 0.2237 } },
		{ { 2.1465, -2.4363, 0.9862 }, { 0.5294, -0.0964,-0.0198 }, { 0.3711, 0.2564, -0.1754 } },
		{ { 0.2859, -0.1965, 0.1490 }, { -0.1152, 0.5383,-0.1248 }, { -0.2278, 1.3401,-0.6411 } },
		{ { 1.2494, -1.0582, 0.5139 }, { 1.2526, -0.0896,-0.1790 }, { 0.9096, -1.5152, 0.8835 } },
		{ { 1.0211, -0.6213, 0.2708 }, { 1.1609, -0.7834, 0.2768 }, { 1.4482, -1.2945, 0.3900 } },
		{ { 1.1870, -1.0146, 0.7256 }, { 0.0837, 0.4875, -0.0303 }, { 0.1539, 0.1525,  0.0870 } },
		{ { 0.7912, 0.2191,  0.0450 }, { 0.3797, 0.4546, -0.1035 }, { -0.6531, 1.3267,-0.4818 } },
		{ { 0.2770, 0.6165, -0.0564 }, { 0.2694, 0.8452, -0.3600 }, { 0.0440, 0.3500, -0.0032 } },
		{ { -0.0950, 0.9728,-0.0345 }, { -0.2918, 1.1718,-003134 }, { 0.1824, -0.2680, 0.2526 } },
	};
	for (i = 0; i < MAXFREQ; i++){
		codeCor[i] = 0;
		codeCor[i] = coef[Prn - 1][i][0] * elvRad + coef[Prn - 1][i][1] * elvRad * elvRad + coef[Prn - 1][i][2] * elvRad * elvRad * elvRad;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rax
leaq (%rax,%rax,8), %rax
leaq 0x49d91(%rip), %rcx     # 0x6aca0
leaq (%rcx,%rax,8), %rax
movq $-0x9, %rcx
movsd 0x8(%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%rsi)
addq $0x8, %rsi
addq $0x3, %rcx
jne 0x20f1a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20f88
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 0x20f6d
jmp 0x20f8a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21003
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 0x20fdc
cmpb $0x23, %cl
ja 0x20fe6
btq %r10, %rdi
jae 0x20ff9
movb (%rsi), %cl
incq %rsi
movb $0x1, %r9b
testb %cl, %cl
jne 0x20fb9
jmp 0x20fff
orl $0x2, %r10d
cmpl $0x23, %r10d
je 0x20fff
incl %edx
movb %cl, (%rbx,%rax)
incq %rax
movb (%rsi), %cl
xorl %r9d, %r9d
testb %cl, %cl
jne 0x20fb6
jmp 0x21005
btq %r10, %r8
jae 0x20fe6
movl %eax, %edx
jmp 0x21005
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 0x2103b
btq %rdx, %rcx
jae 0x2103b
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x21020
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4958a(%rip), %rdx     # 0x6a5f5
movq %rdx, %rsi
callq 0x1126a
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 0x210eb
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 0x210dc
btq %rdi, %rdx
jae 0x210dc
incq %r15
incq %rsi
cmpq %r13, %rsi
jb 0x210be
jmp 0x210eb
movb %dil, (%r14,%rcx)
incq %rcx
incq %rsi
cmpq %r13, %rsi
jb 0x210b7
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 0x1126a
leaq -0x50(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x2112a
callq 0x85d0
movq %r14, %rdi
callq 0x8830
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21146
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x21157
callq 0x85d0
movq %r14, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2147d
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x8450
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x88a0
movq 0x40(%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x21451
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x2145f
callq 0x85d0
movq %r14, %rdi
callq 0x8460
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2266c
movq %r15, %r14
cmpq %r12, %r15
jne 0x21427
leaq 0x60(%rbx), %rdi
callq 0x8760
leaq 0x30(%rbx), %rdi
callq 0x222ce
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2235c
movq %rax, %rdi
callq 0x10614
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1143c
movq %r14, %rdi
movq %r15, %rsi
callq 0x226ac
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x214fa
callq 0x85d0
leaq 0x8(%r14), %rax
cmpq %rax, %r15
je 0x2155c
movq 0x6cabe(%rip), %r14     # 0x8dfc8
leaq 0x49f6f(%rip), %rsi     # 0x6b480
movl $0x2e, %edx
movq %r14, %rdi
callq 0x8730
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x8730
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 0x2160c
movl $0x200, %edi            # imm = 0x200
callq 0x8640
movq %rax, %r12
movq %rax, %rdi
callq 0x8af0
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 0x2161b
leaq 0x60(%r14), %r12
movq %r12, %rdi
callq 0x8910
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 0x1143c
movq %r15, 0x20(%r13)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2274a
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x21604
callq 0x85d0
movq %r12, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6c9a6(%rip), %rdi     # 0x8dfc8
leaq 0x49e86(%rip), %rsi     # 0x6b4af
callq 0x8620
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
leaq 0x49e88(%rip), %rsi     # 0x6b4c8
movq %rax, %rdi
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
jne 0x21680
jmp 0x21685
movq %rax, %rbx
movq %r12, %rdi
jmp 0x21680
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x21685
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1143c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x226ac
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x218e7
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 0x2190d
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21a75
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 0x1cf58
cvtsi2sdl 0x8(%r15), %xmm1
cvtsi2sdl 0x4(%r15), %xmm0
mulsd 0x48f2a(%rip), %xmm0    # 0x6a8b8
mulsd 0x48f2a(%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 0x1d5a4
movq (%r12), %rcx
movq %rcx, %rax
subq 0x8(%r14), %rax
movslq 0x10(%r14), %rsi
cmpq %rsi, %rax
jle 0x21a75
movq %rcx, %rax
cqto
idivq %rsi
subq %rdx, %rcx
movq %rcx, 0x8(%r14)
movq (%r14), %rdi
callq 0x8450
movq (%r14), %rdi
callq 0x88a0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x219fa
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 0x49b04(%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 0x8af0
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 0x8b40