LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::md_julday(int, int, int)
int md_julday(int iyear,int imonth,int iday){
	int iyr, result;
	int doy_of_month[12] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304,
			334 };
	if (iyear < 0 || imonth < 0 || iday < 0 || imonth > 12 || iday > 366
			|| (imonth != 0 && iday > 31)) {
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		exit(1);
	}
	iyr = iyear;
	if (imonth <= 2)
		iyr -= 1;
	result = 365 * iyear - 678941 + iyr / 4 - iyr / 100 + iyr / 400 + iday;
	if (imonth != 0)
		result = result + doy_of_month[imonth - 1];
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x8a054(%rip), %rsi     # 0xbd050
movl $0x30, %edx
callq 0x9610
cmpl $0x0, -0x4(%rbp)
jl 0x33033
cmpl $0x0, -0x8(%rbp)
jl 0x33033
cmpl $0x0, -0xc(%rbp)
jl 0x33033
cmpl $0xc, -0x8(%rbp)
jg 0x33033
cmpl $0x16e, -0xc(%rbp)      # imm = 0x16E
jg 0x33033
cmpl $0x0, -0x8(%rbp)
je 0x33054
cmpl $0x1f, -0xc(%rbp)
jle 0x33054
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x8a22d(%rip), %rdi     # 0xbd270
movb $0x0, %al
callq 0x9090
movl $0x1, %edi
callq 0x9910
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jg 0x33069
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
imull $0x16d, -0x4(%rbp), %eax # imm = 0x16D
subl $0xa5c1d, %eax          # imm = 0xA5C1D
movl %eax, -0x5c(%rbp)
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x5c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x58(%rbp)
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x54(%rbp)
movl -0x10(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x330d3
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl -0x50(%rbp,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::gpsweek(int, int, int, int*, int*)
void gpsweek(int year, int month, int day, int* week, int* wd) {
	int mjd;
	if (year != 0) {
		if (month != 0)
			mjd = md_julday(year, month, day);
		else
			mjd = md_julday(year, 1, 1) + day - 1;
	} else
		mjd = day;
	*week = (mjd - 44244) / 7;
	*wd = mjd - 44244 - (*week) * 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x33132
cmpl $0x0, -0x8(%rbp)
je 0x33118
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x32fe0
movl %eax, -0x24(%rbp)
jmp 0x33130
movl -0x4(%rbp), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x32fe0
addl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33138
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl $0xacd4, %eax           # imm = 0xACD4
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
subl $0xacd4, %ecx           # imm = 0xACD4
movq -0x18(%rbp), %rax
imull $0x7, (%rax), %eax
subl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::cur_time(int*, double*)
void cur_time(int* mjd,double* sod){
//	struct timeval tv;
//    struct tm* ptr;
//	gettimeofday(&tv,NULL);
//	ptr = gmtime (&tv.tv_sec);
//	*mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
//	*sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec + tv.tv_usec / 1e6;
//
//	timinc(*mjd, *sod, Taiutc::s_getInstance()->m_getTaiutc(*mjd) - 19.0, mjd, sod);
	struct tm *ptr;
	time_t rawtime;
	time(&rawtime);
	ptr = gmtime(&rawtime);
	*mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
	*sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec;
	// 从UTC转成GPST
	timinc(*mjd, *sod, 38 - 19.0, mjd, sod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x96e0
leaq -0x20(%rbp), %rdi
callq 0x9670
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
addl $0x76c, %edi            # imm = 0x76C
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x32fe0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm1
movsd 0x89bad(%rip), %xmm2    # 0xbce18
mulsd %xmm2, %xmm1
movsd 0x89b99(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd 0x89b57(%rip), %xmm1    # 0xbce08
callq 0x332c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::timinc(int, double, double, int*, double*)
void timinc(int jd, double sec, double delt, int* jd1, double* sec1) {
	*sec1 = sec + delt;
	int inc = (int) (*sec1 / 86400.0);
	*jd1 = jd + inc;
	*sec1 = *sec1 - inc * 86400.0;
	if (*sec1 >= 0)
		return;
	*jd1 = *jd1 - 1;
	*sec1 = *sec1 + 86400;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x89b25(%rip), %xmm1    # 0xbce20
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x89ae2(%rip), %xmm2    # 0xbce20
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x33361
jmp 0x33388
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movsd 0x89aa4(%rip), %xmm0    # 0xbce20
addsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::runtime(char*)
char* runtime(char* buf){
	int iy,im,id,ih,imin,mjd;
	double dsec,sod;
	cur_time(&mjd,&sod);
	mjd2date(mjd,sod,&iy,&im,&id,&ih,&imin,&dsec);
	if(buf!=NULL)
		sprintf(buf,"%02d-%02d-%02d %02d:%02d:%02d",iy,im,id,ih,imin,(int)dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33200
movl -0x20(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x1c(%rbp), %r9
leaq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x33420
cmpq $0x0, -0x8(%rbp)
je 0x3340a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl -0x1c(%rbp), %r10d
cvttsd2si -0x28(%rbp), %eax
leaq 0x89ea9(%rip), %rsi     # 0xbd2a4
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x9150
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::mjd2date(int, double, int*, int*, int*, int*, int*, double*)
void mjd2date(int jd, double sod, int* iyear, int* imonth, int* iday, int* ih,
		int* imin, double* sec) {
	int doy = 0;
	mjd2doy(jd, iyear, &doy);
	yeardoy2monthday(*iyear, doy, imonth, iday);

	*ih =  static_cast<int>( sod / 3600.0);
	*imin = static_cast<int> ((sod - (*ih) * 3600.0) / 60.0);
	*sec = sod - (*ih) * 3600.0 - (*imin) * 60.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x33170
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl -0x3c(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x336d0
movsd -0x10(%rbp), %xmm0
movsd 0x8998e(%rip), %xmm1    # 0xbce10
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm1
movq -0x30(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x89954(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x8994c(%rip), %xmm1    # 0xbce18
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x30(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x8990a(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x38(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x898e3(%rip), %xmm2    # 0xbce18
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::runlocaltime(char*)
char* runlocaltime(char* buf){
	int iy, im, id, ih, imin, mjd;
	double dsec, sod;
	struct tm *ptr;
	time_t rawtime;
	time(&rawtime);
	ptr = localtime(&rawtime);
	mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
	sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec;
	mjd2date(mjd, sod, &iy, &im, &id, &ih, &imin, &dsec);
	if (buf != NULL)
		sprintf(buf, "%02d-%02d-%02d %02d:%02d:%02d", iy, im, id, ih, imin,
				(int) dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x96e0
leaq -0x40(%rbp), %rdi
callq 0x9590
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x14(%rax), %edi
addl $0x76c, %edi            # imm = 0x76C
movq -0x38(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
movq -0x38(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x32fe0
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movq -0x38(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm1
movsd 0x89866(%rip), %xmm2    # 0xbce18
mulsd %xmm2, %xmm1
movsd 0x89852(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x20(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x1c(%rbp), %r9
leaq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x33420
cmpq $0x0, -0x8(%rbp)
je 0x33638
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl -0x1c(%rbp), %r10d
cvttsd2si -0x28(%rbp), %eax
leaq 0x89c7b(%rip), %rsi     # 0xbd2a4
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x9150
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::run_timefmt(int, double, char*)
char* run_timefmt(int mjd,double sod,char* buf){
	int iy,im,id,ih,imin;
	double dsec;
	mjd2date(mjd,sod,&iy,&im,&id,&ih,&imin,&dsec);
	if(buf!=NULL)
		sprintf(buf,"%02d-%02d-%02d %02d:%02d:%02d",iy,im,id,ih,imin,(int)dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x4(%rbp), %edi
movsd -0x10(%rbp), %xmm0
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x2c(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x33420
cmpq $0x0, -0x18(%rbp)
je 0x336c5
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movl -0x2c(%rbp), %r10d
cvttsd2si -0x38(%rbp), %eax
leaq 0x89bee(%rip), %rsi     # 0xbd2a4
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x9150
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x8998f(%rip), %rsi     # 0xbd080
movl $0x30, %edx
callq 0x9610
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3371b
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3372b
movl -0x4(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x33732
movl $0x1d, -0x4c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0xc, -0x58(%rbp)
jge 0x33785
movl -0x54(%rbp), %eax
movslq -0x58(%rbp), %rcx
subl -0x50(%rbp,%rcx,4), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jle 0x3375b
jmp 0x3377a
movl -0x54(%rbp), %ecx
movslq -0x58(%rbp), %rax
addl -0x50(%rbp,%rax,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x58(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x33785
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x3373f
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::yr2year(int&)
void yr2year(int& yr) {
	if (yr > 1900)
		return;
	if (yr <= 30)
		yr += 2000;
	else
		yr += 1900;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x76c, (%rax)          # imm = 0x76C
jle 0x337e6
jmp 0x3380d
movq -0x8(%rbp), %rax
cmpl $0x1e, (%rax)
jg 0x337ff
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x7d0, %ecx            # imm = 0x7D0
movl %ecx, (%rax)
jmp 0x3380d
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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
subq $0xa0, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x897f2(%rip), %rsi     # 0xbd0b0
movl $0x30, %edx
callq 0x9610
movq $0x0, -0x58(%rbp)
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
leaq -0x64(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x6c(%rbp), %rcx
leaq -0x70(%rbp), %r8
leaq -0x74(%rbp), %r9
leaq -0x80(%rbp), %rax
movq %rax, (%rsp)
callq 0x33420
cmpl $0x7b2, -0x64(%rbp)     # imm = 0x7B2
jl 0x3391c
movl $0x833, %eax            # imm = 0x833
cmpl -0x64(%rbp), %eax
jl 0x3391c
cmpl $0x1, -0x68(%rbp)
jl 0x3391c
movl $0xc, %eax
cmpl -0x68(%rbp), %eax
jge 0x33929
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x339fb
movl -0x64(%rbp), %eax
subl $0x7b2, %eax            # imm = 0x7B2
imull $0x16d, %eax, %eax      # imm = 0x16D
movl %eax, -0x8c(%rbp)
movl -0x64(%rbp), %eax
subl $0x7b1, %eax            # imm = 0x7B1
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8c(%rbp), %eax
addl %ecx, %eax
movl -0x68(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl -0x50(%rbp,%rcx,4), %eax
addl -0x6c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x88(%rbp)
movl -0x64(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x81(%rbp)
jne 0x33995
cmpl $0x3, -0x68(%rbp)
setge %al
movb %al, -0x81(%rbp)
movl -0x88(%rbp), %eax
movb -0x81(%rbp), %sil
xorl %ecx, %ecx
movl $0x1, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
addl %ecx, %eax
movl %eax, -0x5c(%rbp)
movsd -0x80(%rbp), %xmm0
callq 0x9c90
cvttsd2si %xmm0, %eax
movl %eax, -0x60(%rbp)
movslq -0x5c(%rbp), %rax
imulq $0x15180, %rax, %rax    # imm = 0x15180
imull $0xe10, -0x70(%rbp), %ecx # imm = 0xE10
movslq %ecx, %rcx
addq %rcx, %rax
imull $0x3c, -0x74(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movslq -0x60(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x33c36
movsd -0x10(%rbp), %xmm0
movsd 0x89204(%rip), %xmm1    # 0xbce20
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
imull $0x7, -0x4(%rbp), %eax
addl %eax, %ecx
addl $0xacd4, %ecx           # imm = 0xACD4
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x33c57
movsd -0x10(%rbp), %xmm0
movsd 0x891d6(%rip), %xmm1    # 0xbce20
callq 0x99f0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x891aa(%rip), %xmm1    # 0xbce38
ucomisd %xmm1, %xmm0
jbe 0x33c9b
movl $0x3, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33d80
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x33cd5
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33cad
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x33d6d
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x93d0
leaq -0x130(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x24(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
addq %rax, %rsi
movl -0x10(%rbp), %ecx
subl $0x2, %ecx
xorl %edx, %edx
callq 0x33e20
leaq -0x130(%rbp), %rdi
callq 0x33d80
cmpl $0x0, %eax
jne 0x33d60
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x30, (%rax,%rcx)
jmp 0x33d62
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33cf1
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x34020
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x38e80
testb $0x1, %al
jne 0x3400b
jmp 0x34013
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x34020
jmp 0x34015
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33fe5
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3408a
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull -0x8(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x9a60
cmpl $0x0, %eax
jne 0x3407d
jmp 0x3408a
jmp 0x3407f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34055
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x34099
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92e0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x34100
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x340f3
jmp 0x34100
jmp 0x340f5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x340d5
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x34111
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x34117
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xd(%rbp)
je 0x34170
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0xd(%rbp)
je 0x34170
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x34179
jmp 0x34184
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3412f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92e0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x34208
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x341fb
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x341fb
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
subl $0x20, %edx
movb %dl, (%rax,%rcx)
jmp 0x341fd
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x341bf
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92e0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x34288
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x3427b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x3427b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl $0x20, %edx
movb %dl, (%rax,%rcx)
jmp 0x3427d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3423f
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x19(%rbp)
je 0x348be
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x19(%rbp)
je 0x348be
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x348be
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x348c7
jmp 0x348e8
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x348da
jmp 0x348e8
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3487b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x87c85(%rip), %xmm1    # 0xbce78
subsd %xmm1, %xmm0
callq 0x9e00
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x87c6a(%rip), %xmm1    # 0xbce78
subsd %xmm1, %xmm0
callq 0x91a0
movsd %xmm0, -0x28(%rbp)
movsd 0x87c4c(%rip), %xmm0    # 0xbce70
subsd -0x10(%rbp), %xmm0
callq 0x9e00
movsd %xmm0, -0x30(%rbp)
movsd 0x87c35(%rip), %xmm0    # 0xbce70
subsd -0x10(%rbp), %xmm0
callq 0x91a0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x30(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x94f0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x35510
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x35503
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x354c4
jmp 0x35505
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x354b5
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x35572
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x35565
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x35526
jmp 0x35567
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x35517
movq -0x20(%rbp), %rdi
callq 0x9900
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3570e
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x356c9
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x95e0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3575f
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
divsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3572a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x357cd
movsd -0x28(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3578e
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x94f0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x35846
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3580c
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x35770
callq 0x95e0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9900
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
addl $-0x42, %eax
subl $0x2, %eax
jb 0x36732
jmp 0x36728
movl -0x1c(%rbp), %eax
subl $0x52, %eax
je 0x36757
jmp 0x3677a
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd 0x86798(%rip), %xmm1    # 0xbcee8
callq 0x332c0
jmp 0x3677a
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd 0x86693(%rip), %xmm1    # 0xbce08
callq 0x332c0
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x367bd
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x36799
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x36821
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
je 0x36814
movl $0x0, -0x18(%rbp)
jmp 0x36821
jmp 0x36816
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x367f3
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3684f
movb $0x0, -0x1(%rbp)
jmp 0x3695a
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x36889
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x36880
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3685f
movb $0x1, -0x1(%rbp)
jmp 0x3695a
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x3694a
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jl 0x368dc
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3688f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x3693b
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jl 0x36930
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3693b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x368e5
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x36945
jmp 0x3694a
jmp 0x3688f
cmpl $0x0, -0x20(%rbp)
jg 0x36956
movb $0x0, -0x1(%rbp)
jmp 0x3695a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x36e33
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x36e26
movl $0x1, -0x4(%rbp)
jmp 0x36e3a
jmp 0x36e28
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x36e05
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, %rax
je 0x37a3d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
shll $0x10, %eax
cltq
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x37a3b
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x37a2e
movq -0x18(%rbp), %rax
xorq $0x1864cfb, %rax        # imm = 0x1864CFB
movq %rax, -0x18(%rbp)
jmp 0x37a30
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x379ff
jmp 0x379c4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movsbl -0x1(%rbp), %eax
cmpl $0x47, %eax
jne 0x3860a
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3866f
movsbl -0x1(%rbp), %eax
cmpl $0x52, %eax
jne 0x38643
movsd 0x849d5(%rip), %xmm0    # 0xbcff0
addsd -0x10(%rbp), %xmm0
movsd 0x847f8(%rip), %xmm1    # 0xbce20
callq 0x99f0
movsd 0x849b3(%rip), %xmm1    # 0xbcfe8
divsd %xmm1, %xmm0
callq 0x39050
movl %eax, -0x2c(%rbp)
jmp 0x3866d
movsbl -0x1(%rbp), %eax
cmpl $0x45, %eax
jne 0x38654
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3866b
movsbl -0x1(%rbp), %eax
cmpl $0x43, %eax
jne 0x38669
movq -0x28(%rbp), %rdi
callq 0x37a50
movl %eax, -0x2c(%rbp)
jmp 0x3866b
jmp 0x3866d
jmp 0x3866f
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x3877c
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xbf0b1(%rip), %rax     # 0xf7780
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd -0x10(%rbp), %xmm2
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xbf086(%rip), %rax     # 0xf7780
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xbf04d(%rip), %rax     # 0xf7780
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x386a5
popq %rbp
retq
nop
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x387d1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x387bb
jp 0x387bb
jmp 0x387c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x387c6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x38799
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)