LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::yeardoy2monthday(int, int, int*, int*)
void yeardoy2monthday(int iyear, int idoy, int* imonth, int* iday) {
	int days_in_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int id, i;
	if ((iyear % 4 == 0 && iyear % 100 != 0) || iyear % 400 == 0)
		days_in_month[1] = 29;
	id = idoy;
	for (i = 0; i < 12; i++) {
		id = id - days_in_month[i];
		if (id > 0)
			continue;
		*iday = id + days_in_month[i];
		*imonth = i + 1;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %r8
movaps 0x46b3b(%rip), %xmm0    # 0x60b50
movaps %xmm0, -0x10(%rbp)
movaps 0x46b20(%rip), %xmm0    # 0x60b40
movaps %xmm0, -0x20(%rbp)
movaps 0x46b05(%rip), %xmm0    # 0x60b30
movaps %xmm0, -0x30(%rbp)
testb $0x3, %dil
sete %r9b
movl $0x64, %r10d
movl %edi, %eax
cltd
idivl %r10d
testl %edx, %edx
setne %r10b
movl $0x190, %r11d           # imm = 0x190
movl %edi, %eax
cltd
idivl %r11d
testl %edx, %edx
je 0x1a05e
andb %r10b, %r9b
je 0x1a065
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
cmpq $0xc, %rax
je 0x1a083
movl %esi, %edx
subl -0x30(%rbp,%rax,4), %edx
jle 0x1a07c
incq %rax
movl %edx, %esi
jmp 0x1a067
movl %esi, (%rcx)
incl %eax
movl %eax, (%r8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19e07
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 0x1a170
xorl %eax, %eax
jmp 0x1a1e5
imull $0x16d, %eax, %edx      # imm = 0x16D
leal -0x7b1(%rax), %esi
shrl $0x2, %esi
leal -0x1(%rcx), %edi
leaq 0x469d7(%rip), %r8      # 0x60b60
movl -0x1c(%rbp), %r9d
testb $0x3, %al
sete %al
cmpl $0x3, %ecx
setae %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 0x8ac0
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_O2/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, %r11
movl $0x15180, %ecx          # imm = 0x15180
movq %rdi, %rax
cqto
idivq %rcx
movq %rax, %r8
movl $0x5b5, %ecx            # imm = 0x5B5
cltd
idivl %ecx
movl %eax, %esi
movl %edx, %ecx
leaq 0x4696b(%rip), %rdi     # 0x60b90
xorl %edx, %edx
pushq $0x30
popq %rax
cmpq $0x30, %rdx
je 0x1a246
movl %ecx, %r9d
subl (%rdi), %r9d
jl 0x1a244
incq %rdx
addq $0x4, %rdi
movl %r9d, %ecx
jmp 0x1a22a
movl %edx, %eax
pushq $0xc
popq %rdi
xorl %edx, %edx
divl %edi
movl %eax, %r9d
movl %edx, %r10d
imull $0xfffeae80, %r8d, %eax # imm = 0xFFFEAE80
addl %eax, %r11d
movl $0xe10, %edi            # imm = 0xE10
movl %r11d, %eax
cltd
idivl %edi
leal (%r9,%rsi,4), %edi
addl $0x7b2, %edi            # imm = 0x7B2
leal 0x1(%r10), %esi
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movw $0x3c, %r8w
movl %edx, %eax
cwtd
idivw %r8w
cwtl
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
incl %ecx
pushq $0x3c
popq %r8
movl %r11d, %eax
cltd
idivl %r8d
cvtsi2sd %edx, %xmm0
movsd %xmm0, -0x18(%rbp)
movl %ecx, %edx
callq 0x19b34
movsd -0x20(%rbp), %xmm1
mulsd 0x465e8(%rip), %xmm1    # 0x608a8
movsd -0x28(%rbp), %xmm0
mulsd 0x465e3(%rip), %xmm0    # 0x608b0
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_O2/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 0x1a310
movapd %xmm0, %xmm1
divsd 0x465c0(%rip), %xmm1    # 0x608c0
cvttsd2si %xmm1, %eax
imull $0x7, %edi, %ecx
addl %ecx, %eax
addl $0xacd4, %eax           # imm = 0xACD4
movl %eax, (%rsi)
testq %rbx, %rbx
je 0x1a326
movsd 0x465a3(%rip), %xmm1    # 0x608c0
callq 0x8840
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
xorl %eax, %eax
ucomisd 0x46588(%rip), %xmm0    # 0x608d8
movq %rdi, %r12
seta %al
leal (%rax,%rax,2), %r15d
callq 0x1a3ea
movl %ebx, %edx
imull %r14d, %edx
addl %r15d, %edx
movslq %eax, %rcx
movslq %edx, %rax
cmpq %rax, %rcx
jge 0x1a37d
movb $0x20, (%r12,%rcx)
incq %rcx
jmp 0x1a36e
movb $0x0, (%r12,%rax)
movl %r15d, %r15d
addq %r12, %r15
movslq %ebx, %r13
addl $-0x2, %ebx
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
leaq -0x130(%rbp), %r12
subq $0x1, %r14
jb 0x1a3d8
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x8390
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x1a42f
movq %r12, %rdi
callq 0x1a3ea
testl %eax, %eax
jne 0x1a3d3
movb $0x30, 0x1(%r15)
addq %r13, %r15
jmp 0x1a39e
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r13d, %r13d
testl %edi, %edi
cmovlel %r13d, %r15d
pushq $-0x1
popq %r12
cmpq %r13, %r15
je 0x1a583
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d4ec
testb %al, %al
jne 0x1a580
incq %r13
addq $0x20, %r14
jmp 0x1a563
movl %r13d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rcx, %r14
movq %rdx, %r15
movslq %esi, %rbx
xorl %r13d, %r13d
testl %edi, %edi
movl $0x0, %r12d
movl %edi, -0x2c(%rbp)
cmovgl %edi, %r12d
cmpq %r13, %r12
je 0x1a5dd
movq %r15, %rdi
movq %r14, %rsi
callq 0x8890
testl %eax, %eax
je 0x1a5da
incq %r13
addq %rbx, %r15
jmp 0x1a5be
movl %r13d, %r12d
cmpl -0x2c(%rbp), %r12d
pushq $-0x1
popq %rax
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_O2/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
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmpq %rdx, %rcx
je 0x1a626
cmpb %bl, (%r14,%rdx)
je 0x1a624
incq %rdx
jmp 0x1a614
movl %edx, %ecx
cmpl %eax, %ecx
pushq $-0x1
popq %rax
cmovnel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]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 0x1a658
btq %rdx, %rcx
jae 0x1a658
incq %rax
jmp 0x1a644
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x1a68b
movb (%rbx,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x1a686
addb $-0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
jmp 0x1a66f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x1a6c6
movb (%rbx,%rcx), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x1a6c1
orb $0x20, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
jmp 0x1a6aa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a97c
btq %rdx, %rcx
jae 0x1a97c
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x1a961
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x418, %rsp            # imm = 0x418
movq %r9, -0x30(%rbp)
movl %r8d, %r14d
movl %ecx, %ebx
movl %edx, %r13d
movq %rsi, %r15
movl %edi, -0x34(%rbp)
movq %rsi, %rdi
callq 0x1a3ea
movl %eax, %r12d
xorl %r8d, %r8d
cmpb $0x20, %r13b
je 0x1a9cf
movsbl %r13b, %esi
movq %r15, %rdi
callq 0x1a5f7
movl %eax, %r8d
cmpb $0x20, %bl
jne 0x1a9d9
decl %r12d
jmp 0x1a9ed
movsbl %bl, %esi
movq %r15, %rdi
movl %r8d, %ebx
callq 0x1a5f7
movl %ebx, %r8d
movl %eax, %r12d
movq -0x30(%rbp), %rdx
andl $0x0, (%rdx)
cmpl $-0x1, %r12d
sete %al
cmpl %r12d, %r8d
setg %cl
orb %al, %cl
je 0x1aa17
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%rbp), %eax
movslq %r12d, %rbx
cmpb %r14b, (%r15,%rbx)
je 0x1aa28
movb %r14b, 0x1(%r15,%rbx)
movb $0x0, 0x2(%r15,%rbx)
addq $0x2, %rbx
movslq %r8d, %r13
leaq -0x440(%rbp), %r12
cltq
movq %rax, -0x40(%rbp)
cmpq %rbx, %r13
jge 0x1aa05
cmpb %r14b, (%r15,%r13)
je 0x1aa52
incq %r13
jmp 0x1aa42
movslq %r8d, %rax
cmpq %rax, %r13
jle 0x1aa8c
movl %r13d, %ecx
subl %r8d, %ecx
movq %r12, %rdi
movq %r15, %rsi
movl %r8d, %edx
callq 0x1a42f
movq -0x30(%rbp), %rax
movslq (%rax), %rdi
imulq -0x40(%rbp), %rdi
addq 0x10(%rbp), %rdi
movq %r12, %rsi
callq 0x85c0
movq -0x30(%rbp), %rdx
jmp 0x1aaa9
cmpb $0x0, -0x34(%rbp)
jne 0x1aaab
movslq (%rdx), %rax
imulq -0x40(%rbp), %rax
movq 0x10(%rbp), %rcx
movb $0x0, 0x2(%rcx,%rax)
movw $0x2020, (%rcx,%rax)    # imm = 0x2020
incl (%rdx)
incq %r13
movl %r13d, %r8d
jmp 0x1aa42
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1aaee
movsd 0x45df2(%rip), %xmm1    # 0x608e0
je 0x1aaf8
movsd 0x45df0(%rip), %xmm0    # 0x608e8
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd %xmm1, %xmm3
cmpnlesd 0x45ddb(%rip), %xmm3    # 0x608f0
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 0x8160
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd -0x38(%rbp), %xmm1
movsd 0x44dbe(%rip), %xmm0    # 0x5f920
subsd %xmm1, %xmm0
ucomisd 0x45d8a(%rip), %xmm0    # 0x608f8
jb 0x1ab76
sqrtsd %xmm0, %xmm0
jmp 0x1ab7b
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 0x8160
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x44d1f(%rip), %xmm0    # 0x5f920
subsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
addsd 0x10(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%r14), %xmm0
callq 0x8160
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]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 0x4596c(%rip), %xmm0    # 0x60918
movsd %xmm0, -0x20(%rbp)
callq 0x8bf0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8160
movaps %xmm0, -0x20(%rbp)
movsd 0x45947(%rip), %xmm0    # 0x60918
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x8bf0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x8160
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 0x45a9c(%rip), %xmm1    # 0x60ac0
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x18(%rbx)
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x20(%rbx)
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm4
movsd %xmm4, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x38(%rbx)
movsd %xmm2, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]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 %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %eax
imull %edx, %eax
movslq %eax, %rdi
pushq $0x8
popq %rsi
callq 0x8440
movslq %r12d, %rcx
xorl %edi, %edi
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
movslq %r15d, %r8
shlq $0x3, %r8
shlq $0x3, %rcx
movq %rax, %r9
cmpq %rsi, %rdi
je 0x1b1e8
movq %r9, %r10
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0x1b1dc
movsd (%r14,%r11,8), %xmm0
movsd %xmm0, (%r10)
incq %r11
addq %rcx, %r10
jmp 0x1b1c4
incq %rdi
addq %r8, %r14
addq $0x8, %r9
jmp 0x1b1b9
xorl %edi, %edi
movq %rax, %r8
cmpq %rdx, %rdi
je 0x1b216
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x1b20b
movsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%rbx,%r9,8)
incq %r9
jmp 0x1b1f5
incq %rdi
addq %rcx, %r8
addq %rcx, %rbx
jmp 0x1b1ed
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8780
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
andq $0x0, (%rcx)
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %r12d
xorpd %xmm0, %xmm0
cmpq %rax, %r12
je 0x1b2c1
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %rax
jmp 0x1b2a5
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1b2d1
sqrtsd %xmm0, %xmm0
jmp 0x1b2d6
callq 0x84e0
movsd %xmm0, (%rbx)
xorl %eax, %eax
cmpq %rax, %r12
je 0x1b2f6
movsd (%r15,%rax,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0x1b2dc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
xorpd %xmm0, %xmm0
cmpq %rax, %rdi
je 0x1b326
movsd (%rsi,%rax,8), %xmm1
mulsd (%rdx,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1b30e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rsi
movq %r13, %rdi
callq 0x8440
movq %rax, %rbx
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %rax, %rcx
je 0x1b379
movsd (%r12,%rax,8), %xmm0
subsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x1b35e
movl %r14d, %edi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x1b2ff
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1b397
sqrtsd %xmm0, %xmm0
jmp 0x1b39c
callq 0x84e0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x8780
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_O2/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::betau(double*, double*, double*, double*)
void betau(double* xsat, double* xsun, double* beta, double* u) {
	double xsat_unit[3], nop_unit[3];
	double xsun_unit[3], vsat_unit[3], det;
	unit_vector(3, xsat, xsat_unit, &det);
	cross(xsat, xsat + 3, nop_unit);
	unit_vector(3, nop_unit, nop_unit, &det);
	unit_vector(3, xsun, xsun_unit, &det);
	*beta = PI / 2.0 - acos(dot(3, nop_unit, xsun_unit));

	*u = acos(dot(3, xsat_unit, xsun_unit) / cos(*beta));

	unit_vector(3, xsat + 3, vsat_unit, &det);

	if (dot(3, vsat_unit, xsun_unit)
			> dot(3, vsat_unit, xsat_unit) * dot(3, xsat_unit, xsun_unit))
		*u = -(*u);
	*u = *u - PI;

	while (*u < 0)
		*u = *u + 2 * PI;
	while (*u > 2 * PI)
		*u = *u - 2 * PI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, -0x48(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r14
pushq $0x3
popq %r15
leaq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movl %r15d, %edi
movq %r14, %rsi
callq 0x1b27e
leaq 0x18(%r14), %r13
leaq -0xc0(%rbp), %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1b226
movl %r15d, %edi
movq %rbx, %rsi
movq %rbx, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rcx
callq 0x1b27e
leaq -0xa0(%rbp), %rdx
movl %r15d, %edi
movq %r12, %rsi
movq %rdx, %r12
movq %r14, %rcx
callq 0x1b27e
movl %r15d, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r12, %r14
callq 0x1b2ff
callq 0x85f0
movsd 0x454c6(%rip), %xmm1    # 0x60920
subsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsd %xmm1, (%rax)
movl %r15d, %edi
leaq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x1b2ff
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x8bf0
movsd -0x30(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x85f0
movq -0x48(%rbp), %r12
movsd %xmm0, (%r12)
leaq -0x80(%rbp), %rbx
movl %r15d, %edi
movq %r13, %rsi
movq %rbx, %rdx
leaq -0x40(%rbp), %rcx
callq 0x1b27e
movl %r15d, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b2ff
movsd %xmm0, -0x38(%rbp)
movl %r15d, %edi
movq %rbx, %rsi
leaq -0x60(%rbp), %rdx
callq 0x1b2ff
movq %r12, %rax
mulsd -0x30(%rbp), %xmm0
movsd (%r12), %xmm1
movapd 0x455cd(%rip), %xmm2    # 0x60ac0
xorpd %xmm1, %xmm2
cmpltsd -0x38(%rbp), %xmm0
andpd %xmm0, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
addsd 0x45417(%rip), %xmm0    # 0x60928
xorpd %xmm2, %xmm2
movsd 0x453eb(%rip), %xmm1    # 0x60908
ucomisd %xmm0, %xmm2
jbe 0x1b529
addsd %xmm1, %xmm0
jmp 0x1b51d
movsd 0x453ff(%rip), %xmm2    # 0x60930
ucomisd %xmm1, %xmm0
jbe 0x1b53d
addsd %xmm2, %xmm0
jmp 0x1b531
movsd %xmm0, (%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x1bf27
addl (%rdi,%rcx,4), %eax
incq %rcx
jmp 0x1bf1a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0x1, %eax
cmpq %rcx, %rsi
je 0x1bf4c
leaq 0x1(%rcx), %r8
cmpl %edx, (%rdi,%rcx,4)
movq %r8, %rcx
je 0x1bf39
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bf5a
xorl %eax, %eax
jmp 0x1bfcb
cmpl $-0x1, (%rdx)
je 0x1bfb5
movslq %edi, %rcx
testl %edi, %edi
jle 0x1bf56
movl %edi, %edi
movl %edi, %eax
movl -0x4(%rdx,%rax,4), %r8d
incl %r8d
movl %r8d, -0x4(%rdx,%rax,4)
movq %rdi, %rax
cmpl %esi, %r8d
jge 0x1bfaa
cmpq %rcx, %rax
jge 0x1bfae
movl -0x4(%rdx,%rax,4), %r8d
incl %r8d
movl %r8d, (%rdx,%rax,4)
incq %rax
cmpl %esi, %r8d
jl 0x1bf7f
movq %rdi, %r8
decq %r8
xorl %eax, %eax
cmpl $0x1, %edi
movq %r8, %rdi
jg 0x1bf68
jmp 0x1bfcb
decl %edi
jmp 0x1bf62
testl %edi, %edi
setg %al
jmp 0x1bfcb
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rax, %rdi
je 0x1bfc9
movl %eax, (%rdx,%rax,4)
incq %rax
jmp 0x1bfbc
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movl %edi, %ebx
leal (%rbx,%rbx), %eax
movslq %eax, %rdi
pushq $0x8
popq %r15
movq %r15, %rsi
callq 0x8440
movq %rax, %r12
pushq $0x2
popq %rdi
movq %r15, %rsi
callq 0x8440
movq %rax, %r15
cmpl $0x2, %ebx
jl 0x1c081
movq %r13, -0x40(%rbp)
pushq $0x2
popq %rsi
movl %ebx, %edi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x2cd04
movl %eax, %r13d
testl %eax, %eax
movq %r12, %rsi
jne 0x1c0f2
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
ucomisd %xmm0, %xmm1
movl %ebx, %edx
jbe 0x1c114
shlq $0x3, %rdx
movq %r14, %rdi
movq %rsi, %r12
callq 0x84f0
movq -0x40(%rbp), %r13
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r13)
movsd -0x38(%rbp), %xmm0
jmp 0x1c0e6
movsd (%r14), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x44a36(%rip), %rcx     # 0x60ad0
movsd (%rcx,%rax,8), %xmm1
addsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movlpd %xmm1, (%r14)
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, (%r13)
andpd 0x4385e(%rip), %xmm1    # 0x5f930
movsd 0x43846(%rip), %xmm0    # 0x5f920
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
divsd (%rax), %xmm0
movsd %xmm0, 0x8(%r13)
xorl %r13d, %r13d
movq %r12, %rsi
movq %rsi, %rdi
callq 0x8780
movq %r15, %rdi
callq 0x8780
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r12
leaq (%rsi,%rdx,8), %rsi
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x84f0
movq -0x40(%rbp), %r13
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%r13)
movsd -0x30(%rbp), %xmm0
jmp 0x1c0e6
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
movl $0x1, %ecx
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x1c380
leaq 0x1(%r8), %r9
cmpl %edx, (%rsi,%r8,4)
movq %r9, %r8
jne 0x1c36c
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x8, %ecx
subq $0x1, %rdi
jb 0x1cbc8
movzbl (%rsi), %edx
shll $0x10, %edx
xorq %rdx, %rax
movl %ecx, %edx
subl $0x1, %edx
jb 0x1cbc3
leaq (%rax,%rax), %r8
movq %r8, %r9
xorq $0x1864cfb, %r9         # imm = 0x1864CFB
btl $0x17, %eax
cmovaeq %r8, %r9
movq %r9, %rax
jmp 0x1cba3
incq %rsi
jmp 0x1cb92
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x43, %edi
je 0x1d09f
cmpl $0x45, %edi
je 0x1d0aa
cmpl $0x47, %edi
je 0x1d0aa
cmpl $0x52, %edi
jne 0x1d0a7
pushq %rbp
movq %rsp, %rbp
addsd 0x43a36(%rip), %xmm0    # 0x60aa0
movsd 0x4384e(%rip), %xmm1    # 0x608c0
callq 0x8840
divsd 0x43a29(%rip), %xmm0    # 0x60aa8
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x43a3d(%rip), %rcx     # 0x60ad0
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %edx
popq %rbp
jmp 0x1d0aa
movq %rcx, %rdi
jmp 0x1cbca
pushq $-0x1
popq %rdx
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
decl %edi
movslq %edi, %rax
imulq $0x48, %rax, %rax
leaq 0x43bcf(%rip), %rcx     # 0x60c90
addq %rcx, %rax
addq $0x10, %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1d10c
movsd -0x8(%rax), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd -0x10(%rax), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
addq $0x18, %rax
jmp 0x1d0ca
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x1d13a
movsd (%rdi,%rcx,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rdx
subl %edx, %eax
incq %rcx
jmp 0x1d11f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, %r8b
xorl %eax, %eax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movabsq $0xa00000000, %rdx      # imm = 0xA00000000
incq %rsi
movzbl -0x1(%rsi), %r9d
testl %r9d, %r9d
je 0x1d1a2
testb $0x1, %r8b
je 0x1d183
cmpl $0x23, %r9d
ja 0x1d190
movl %r9d, %r8d
btq %r8, %rcx
jae 0x1d19c
incq %rsi
movb $0x1, %r8b
jmp 0x1d15c
movl %r9d, %r8d
orl $0x2, %r8d
cmpl $0x23, %r8d
je 0x1d1a2
movb %r9b, (%rdi,%rax)
incq %rax
xorl %r8d, %r8d
jmp 0x1d159
btq %r8, %rdx
jae 0x1d190
movl %eax, %eax
movb $0x0, (%rdi,%rax)
popq %rbp
jmp 0x1a947
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x43419(%rip), %rsi     # 0x605e5
leaq -0x58(%rbp), %rdx
callq 0x8260
movq 0x8(%r15), %r13
movslq %r13d, %r12
testq %r12, %r12
pushq $-0x1
popq %rdi
cmovnsq %r12, %rdi
callq 0x8040
movq %rax, %r14
movq (%r15), %r15
movq $0x0, -0x38(%rbp)
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8390
movq %r15, %rax
negq %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
leaq (%rax,%r15), %rdx
incq %r15
cmpq %r13, %rdx
jae 0x1d24c
movzbl -0x1(%r15), %esi
cmpq $0x20, %rsi
ja 0x1d23b
btq %rsi, %rcx
jae 0x1d23b
incq %r15
incq %rdx
jmp 0x1d21d
movq -0x38(%rbp), %rdx
movb %sil, (%r14,%rdx)
incq %rdx
movq %rdx, -0x38(%rbp)
jmp 0x1d216
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0x8260
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87a0
movq %r15, %rdi
callq 0x82c0
movq %r14, %rdi
callq 0x8800
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d28f
movq %rax, %r14
movq %rbx, %rdi
callq 0x82c0
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x1d5c8
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x8450
movq 0x40(%r14), %rax
movq (%rax), %rdi
callq 0x88a0
movq 0x40(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x1d5b3
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x40(%r14), %rdi
callq 0x85d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e5da
movq %rax, %r14
jmp 0x1d57d
leaq 0x60(%rbx), %rdi
callq 0x8730
leaq 0x30(%rbx), %rdi
callq 0x1e1ee
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1e286
movq %rax, %rdi
callq 0xedc5
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x8870
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e63c
movq %rax, %r15
leaq -0x50(%rbp), %rdi
callq 0x82c0
leaq 0x8(%r14), %rax
cmpq %rax, %r15
je 0x1d662
movq 0x6898a(%rip), %rdi     # 0x85fc8
leaq 0x43e2b(%rip), %rsi     # 0x61470
callq 0x8610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
movq %rax, %rdi
callq 0x8310
jmp 0x1d6e6
movl $0x200, %edi            # imm = 0x200
callq 0x8630
movq %rax, %r15
movq %rax, %rdi
callq 0x8ae0
pushq $0x18
popq %rdi
callq 0x8630
movq %rax, %r12
movq %rax, %rdi
callq 0x1e100
movq %r15, (%r12)
movq (%rbx), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x8080
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x1d6f5
leaq 0x60(%r14), %r15
movq %r15, %rdi
callq 0x8900
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8870
movq %r12, 0x20(%r13)
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e6c6
leaq -0x50(%rbp), %rdi
callq 0x82c0
movq %r15, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x688cc(%rip), %rdi     # 0x85fc8
leaq 0x43d9c(%rip), %rsi     # 0x6149f
callq 0x8610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
leaq 0x43d9e(%rip), %rsi     # 0x614b8
movq %rax, %rdi
callq 0x8610
movq %rax, %rdi
callq 0x8310
pushq $0x1
popq %rdi
callq 0x8790
jmp 0x1d741
movq %rax, %rbx
movq %r15, %rdi
callq 0x85d0
jmp 0x1d74d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_openLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Log::m_openLog(string filName,int interval){
	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(interval);
	item->lupd = true;
	item->of = out;
	out->open(filName.c_str(), ios::out);
	if (!(*out)) {
		cout << "can't create logger file " << filName << ",please check 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
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x8870
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e63c
movq %rax, %r12
leaq -0x50(%rbp), %rdi
callq 0x82c0
leaq 0x8(%r14), %rax
cmpq %rax, %r12
je 0x1d7c7
movq 0x68825(%rip), %rdi     # 0x85fc8
leaq 0x43cc6(%rip), %rsi     # 0x61470
callq 0x8610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
movq %rax, %rdi
callq 0x8310
jmp 0x1d858
movl $0x200, %edi            # imm = 0x200
callq 0x8630
movq %rax, %r12
movq %rax, %rdi
callq 0x8ae0
pushq $0x18
popq %rdi
callq 0x8630
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
callq 0x1e11a
movl $0x1, 0x14(%r13)
movq %r12, (%r13)
movq (%rbx), %rsi
pushq $0x10
popq %rdx
movq %r12, %rdi
callq 0x8080
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r12,%rax)
jne 0x1d867
leaq 0x60(%r14), %r15
movq %r15, %rdi
callq 0x8900
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8870
movq %r13, 0x20(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e6c6
leaq -0x50(%rbp), %rdi
callq 0x82c0
movq %r15, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6875a(%rip), %rdi     # 0x85fc8
leaq 0x43c63(%rip), %rsi     # 0x614d8
callq 0x8610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8560
leaq 0x43c66(%rip), %rsi     # 0x614f2
movq %rax, %rdi
callq 0x8610
movq %rax, %rdi
callq 0x8310
pushq $0x1
popq %rdi
callq 0x8790
jmp 0x1d8b3
movq %rax, %rbx
movq %r12, %rdi
callq 0x85d0
jmp 0x1d8bf
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x8870
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e63c
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x82c0
addq $0x8, %rbx
cmpq %rbx, %r14
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30