LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3889d
cmpl $0x0, -0x18(%rbp)
jne 0x3884e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x38840
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x38840
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3884e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x38806
movl $0x1, -0x18(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x38896
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x38896
movq -0x20(%rbp), %rax
movb (%rax), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x38898
jmp 0x3889d
jmp 0x38806
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x34850
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3a960
movq -0x38(%rbp), %rdi
callq 0x3a980
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3a9e0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3a9b0
testb $0x1, %al
jne 0x392c5
jmp 0x39367
leaq -0x10(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x9510
jmp 0x392dc
leaq -0x10(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x9a70
jmp 0x392f3
leaq -0x10(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x39317
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x39337
movq -0x48(%rbp), %rdi
callq 0x9700
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x3aa30
movq %rax, -0x50(%rbp)
jmp 0x39352
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x392a2
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x98b0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x3aa70
movq -0x38(%rbp), %rdi
callq 0x3aa90
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x15730
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3a960
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x92d0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3aab0
movq %rax, -0x68(%rbp)
jmp 0x3999c
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9480
movq -0x78(%rbp), %rdi
callq 0x3a9e0
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3a9b0
testb $0x1, %al
jne 0x399d5
jmp 0x399f2
movb $0x1, -0x1(%rbp)
jmp 0x399f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9480
jmp 0x39a04
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_closeLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_closeLog(string filname){
	map<string, LogItem*>::iterator itr;
	itr = mapOut.find(string(filname));
	def_lock(&_lock);
	if (itr != mapOut.end()) {
		(*(*itr).second).of->flush();
		(*(*itr).second).of->close();
		delete (*itr).second->of;
		delete (*itr).second;
		mapOut.erase(itr);
	}
	map<string,map<string,unsigned int> >::iterator iTtr;
	iTtr = mtimeLog.find(filname);
	if(iTtr != mtimeLog.end()){
		mtimeLog.erase(iTtr);
	}
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3a960
movq -0xb0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x92d0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3aab0
movq %rax, -0x98(%rbp)
jmp 0x3a0f1
movq -0x98(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9480
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x9ad0
movq -0xa8(%rbp), %rdi
callq 0x3a9e0
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3a9b0
testb $0x1, %al
jne 0x3a143
jmp 0x3a1f5
leaq -0x18(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x9510
leaq -0x18(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x9a70
leaq -0x18(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0x3a197
movq -0xb8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x3aa10
movq 0x20(%rax), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x3a1bd
movq -0xc0(%rbp), %rdi
callq 0x9700
movq -0xa8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x3aa30
movq %rax, -0x68(%rbp)
jmp 0x3a1f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9480
jmp 0x3a28a
leaq -0x70(%rbp), %rdi
callq 0x3ac60
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3ac80
movq -0xa8(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x3ace0
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3acb0
testb $0x1, %al
jne 0x3a248
jmp 0x3a271
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
callq 0x3ad10
movq %rax, -0x90(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x95a0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::s_tmeConsume(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::s_tmeConsume(string tag){
	double sec;
	unsigned int tv_end = tickget();
	map<string,unsigned int>::iterator itr;

	itr = timeLog.find(tag);
	if(itr == timeLog.end()){
		cout << "***WARNING(m_tmeConsume) Wrong input tag!" << endl;
		return;
	}
	sec = tv_end - (*itr).second;
	printf("%-60s TIME CONSUME: %10.3lf\n",tag.c_str(),sec / 1000.0);
	timeLog.erase(itr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x8f860
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3aef0
movq -0x48(%rbp), %rsi
leaq 0xbf2cc(%rip), %rdi     # 0xf9ad8
callq 0x3af10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xbf2b4(%rip), %rdi     # 0xf9ad8
callq 0x3af70
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3af40
testb $0x1, %al
jne 0x3a840
jmp 0x3a864
movq 0xbc779(%rip), %rdi     # 0xf6fc0
leaq 0x82d1f(%rip), %rsi     # 0xbd56d
callq 0x9760
movq %rax, %rdi
movq 0xbc743(%rip), %rsi     # 0xf6fa0
callq 0x97c0
jmp 0x3a8cf
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3afa0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movl 0x20(%rcx), %ecx
subl %ecx, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x92b0
movq %rax, %rsi
movsd -0x10(%rbp), %xmm0
movsd 0x82b87(%rip), %xmm1    # 0xbd428
divsd %xmm1, %xmm0
leaq 0x82ceb(%rip), %rdi     # 0xbd597
movb $0x1, %al
callq 0x9090
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq 0xbf212(%rip), %rdi     # 0xf9ad8
callq 0x3afc0
movq %rax, -0x40(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: DoubleString[P]RtConverter/src/Rnxobs/../../include/Rnxobs/Log.h
// Function: bamboo::LogItem::LogItem()
LogItem(){
		of = NULL;
		interval = 86400;
		lupd = false;
		time(&lastActive);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movl $0x15180, 0x10(%rdi)    # imm = 0x15180
movl $0x0, 0x14(%rdi)
addq $0x8, %rdi
callq 0x96e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: DoubleString[P]RtConverter/src/Rnxobs/../../include/Rnxobs/Log.h
// Function: bamboo::LogItem::LogItem(int)
LogItem(int intv){
		of = NULL;
		interval = intv;
		lupd = false;
		time(&lastActive);
		lastActive = (lastActive / intv) * intv; // make it into the nearest
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x8, %rdi
callq 0x96e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Rnxobs/Patterns.cpp
// Function: bamboo::Patterns::Patterns()
Patterns::Patterns(){
	memset(this->fform,0,sizeof(this->fform));
	memset(this->fname,0,sizeof(this->fname));
	this->MAXFILE = 100;
	Patterns::readFile();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x6400, %rdi           # imm = 0x6400
xorl %esi, %esi
movl $0x6400, %edx           # imm = 0x6400
callq 0x93d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x6400, %edx           # imm = 0x6400
callq 0x93d0
movq -0x10(%rbp), %rdi
movl $0x64, 0xc804(%rdi)
callq 0x3e3c0
addq $0x10, %rsp
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/Rnxobs/../../include/Rnxobs/Rnxobs.h
// Function: bamboo::Rnxobs::Rnxobs()
Rnxobs(){
		// Reset Varibles
		iRead = 0;
		mjd = 0;
		sod = 0;
		isOutputOpen = false;
		outVer = 2.11;
		memset(flag,0,sizeof(int) * MAXSAT * MAXFREQ);
		memset(obs,0,sizeof(double) * MAXSAT * 2 * MAXFREQ);
		memset(fob,0,sizeof(char) * MAXSAT * MAXFREQ * 2 * LEN_OBSTYPE);
		memset(outFile,0,sizeof(outFile));
		memset(snr,0,sizeof(snr));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xb3955(%rip), %rax     # 0xf6810
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x5fb0, %rdi           # imm = 0x5FB0
callq 0x9a50
movq -0x10(%rbp), %rdi
addq $0x5fd0, %rdi           # imm = 0x5FD0
callq 0x9a50
movq -0x10(%rbp), %rdi
addq $0x5ff0, %rdi           # imm = 0x5FF0
callq 0x9a50
movq -0x10(%rbp), %rdi
movl $0x0, 0x680c(%rdi)
movl $0x0, 0x6010(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x3fc8(%rdi)
movb $0x0, 0x6810(%rdi)
movsd 0x7a838(%rip), %xmm0    # 0xbd758
movsd %xmm0, 0x6818(%rdi)
addq $0x6014, %rdi           # imm = 0x6014
xorl %esi, %esi
movl $0x7f8, %edx            # imm = 0x7F8
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x1fe0, %edx           # imm = 0x1FE0
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0x3fd0, %rdi           # imm = 0x3FD0
xorl %esi, %esi
movl $0xff0, %edx            # imm = 0xFF0
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0x6820, %rdi           # imm = 0x6820
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0x4fc0, %rdi           # imm = 0x4FC0
xorl %esi, %esi
movl $0xff0, %edx            # imm = 0xFF0
callq 0x93d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/RtRinexStream.cpp
// Function: bamboo::RtRinexStream::openStream()
void RtRinexStream::openStream() {
	configs_sav = Deploy::s_getConfigures();
	def_thread_t pid_handle;
	lcont = true;
	time(&lastCheck);
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthRniexStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthRinexStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2070, %rsp           # imm = 0x2070
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2070(%rbp)
leaq -0x2048(%rbp), %rdi
movq %rdi, -0x2068(%rbp)
callq 0x4f7c0
movq -0x2068(%rbp), %rsi
leaq 0xb672d(%rip), %rdi     # 0xf9b28
callq 0x44f90
jmp 0x43402
leaq -0x2048(%rbp), %rdi
callq 0x4f750
movq -0x2070(%rbp), %rdi
movb $0x1, 0x20(%rdi)
addq $0x40, %rdi
callq 0x96e0
movq -0x2070(%rbp), %rcx
leaq -0x2060(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x75(%rip), %rdx        # 0x434b0
callq 0x9dc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x43494
movq 0xb3b71(%rip), %rdi     # 0xf6fc0
leaq 0x7a5c5(%rip), %rsi     # 0xbda1b
callq 0x9760
movq %rax, %rdi
movq 0xb3b3b(%rip), %rsi     # 0xf6fa0
callq 0x97c0
movl $0x1, %edi
callq 0x9910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2050(%rbp)
movl %eax, -0x2054(%rbp)
leaq -0x2048(%rbp), %rdi
callq 0x4f750
jmp 0x4349d
addq $0x2070, %rsp           # imm = 0x2070
popq %rbp
retq
movq -0x2050(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxobs/RtRinexStream.cpp
// Function: bamboo::RtRinexStream::openStream(std::__cxx11::list<bamboo::RtConverter*, std::allocator<bamboo::RtConverter*>>&)
void RtRinexStream::openStream(list<RtConverter*>& svrs_in) {
	configs_sav = Deploy::s_getConfigures();
	def_thread_t pid_handle;
	lcont = true;
	time(&lastCheck);
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthRniexStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthRinexStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
	this->m_svrs = svrs_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2080, %rsp           # imm = 0x2080
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2078(%rbp)
leaq -0x2050(%rbp), %rdi
movq %rdi, -0x2070(%rbp)
callq 0x4f7c0
movq -0x2070(%rbp), %rsi
leaq 0xb6609(%rip), %rdi     # 0xf9b28
callq 0x44f90
jmp 0x43526
leaq -0x2050(%rbp), %rdi
callq 0x4f750
movq -0x2078(%rbp), %rdi
movb $0x1, 0x20(%rdi)
addq $0x40, %rdi
callq 0x96e0
movq -0x2078(%rbp), %rcx
leaq -0x2068(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xaf(%rip), %rdx       # 0x434b0
callq 0x9dc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x435b8
movq 0xb3a4d(%rip), %rdi     # 0xf6fc0
leaq 0x7a4a1(%rip), %rsi     # 0xbda1b
callq 0x9760
movq %rax, %rdi
movq 0xb3a17(%rip), %rsi     # 0xf6fa0
callq 0x97c0
movl $0x1, %edi
callq 0x9910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2058(%rbp)
movl %eax, -0x205c(%rbp)
leaq -0x2050(%rbp), %rdi
callq 0x4f750
jmp 0x435d5
movq -0x2078(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rdi
callq 0x45080
addq $0x2080, %rsp           # imm = 0x2080
popq %rbp
retq
movq -0x2058(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/Deploy.cpp
// Function: bamboo::Deploy::Deploy()
Deploy::Deploy() {
	lastAct = 0;
	ephport = -1;
	if (s_count++ == 0)
		def_initlock(&s_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x6b0, %rax            # imm = 0x6B0
movq %rax, %rcx
addq $0x1540, %rcx           # imm = 0x1540
movq %rcx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x9a50
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0x4f6cc
movq -0x20(%rbp), %rdi
addq $0x1bf8, %rdi           # imm = 0x1BF8
callq 0x45af0
movq -0x20(%rbp), %rdi
addq $0x1c10, %rdi           # imm = 0x1C10
callq 0x4fd50
movq -0x20(%rbp), %rax
movq $0x0, 0x1bf0(%rax)
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movl 0xac44e(%rip), %eax     # 0xfbb78
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xac443(%rip)     # 0xfbb78
cmpl $0x0, %eax
jne 0x4f74a
leaq 0xac43f(%rip), %rdi     # 0xfbb80
xorl %eax, %eax
movl %eax, %esi
callq 0x9ae0
addq $0x30, %rsp
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/RtConverter/Deploy.cpp
// Function: bamboo::Deploy::s_getConfigures()
Deploy Deploy::s_getConfigures() {
	def_lock(&s_mutex);
	Deploy ret;
	ret = *sInstance;
	def_unlock(&s_mutex);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xac3a2(%rip), %rdi     # 0xfbb80
callq 0x9ad0
movq -0x28(%rbp), %rdi
movb $0x0, -0x9(%rbp)
callq 0x4f6a0
movq -0x28(%rbp), %rdi
movq 0xac375(%rip), %rsi     # 0xfbb70
callq 0x44f90
jmp 0x4f802
leaq 0xac377(%rip), %rdi     # 0xfbb80
callq 0x95a0
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x4f83a
jmp 0x4f831
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4f750
jmp 0x4f844
movq -0x28(%rbp), %rdi
callq 0x4f750
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/Deploy.cpp
// Function: bamboo::Deploy::s_updateConfigures()
bool Deploy::s_updateConfigures() {
	struct stat st;
	int result,lupdate = false;
	result = stat(sInstance->f_jsonConfigures, &st);
	//��ʾ�ļ�״̬��Ϣ
	if (result != 0) {
		printf("file = %s,monitor file is not exist!", sInstance->f_jsonConfigures);
		return false;
	}
	if (sInstance->lastAct != st.st_mtime) {
		def_lock(&s_mutex);
		sInstance->m_readConfiguresJson(false);
		def_unlock(&s_mutex);
		lupdate = true;
	}
	return lupdate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0xa0(%rbp)
movq 0xac304(%rip), %rdi     # 0xfbb70
addq $0x1c40, %rdi           # imm = 0x1C40
leaq -0x98(%rbp), %rsi
callq 0x96b0
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
je 0x4f8b0
movq 0xac2db(%rip), %rsi     # 0xfbb70
addq $0x1c40, %rsi           # imm = 0x1C40
leaq 0x6e1f2(%rip), %rdi     # 0xbda95
movb $0x0, %al
callq 0x9090
movb $0x0, -0x1(%rbp)
jmp 0x4f903
movq 0xac2b9(%rip), %rax     # 0xfbb70
movq 0x1bf0(%rax), %rax
cmpq -0x40(%rbp), %rax
je 0x4f8f4
leaq 0xac2b5(%rip), %rdi     # 0xfbb80
callq 0x9ad0
movq 0xac299(%rip), %rdi     # 0xfbb70
xorl %esi, %esi
callq 0x4d5c0
leaq 0xac29b(%rip), %rdi     # 0xfbb80
callq 0x95a0
movl $0x1, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::RtConverter()
RtConverter::RtConverter() {
	initlock(&_mutex);
	obsdelay = 5;
	port = -1;
	type = ConvType::obsbnc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x870, %rdi            # imm = 0x870
callq 0x323c0
movq -0x10(%rbp), %rdi
addq $0xa0ec8, %rdi          # imm = 0xA0EC8
callq 0x54060
movq -0x10(%rbp), %rdi
addq $0xa0ee0, %rdi          # imm = 0xA0EE0
callq 0x54080
movq -0x10(%rbp), %rdi
addq $0xa0f10, %rdi          # imm = 0xA0F10
callq 0x540a0
movq -0x10(%rbp), %rdi
addq $0xa0f40, %rdi          # imm = 0xA0F40
xorl %eax, %eax
movl %eax, %esi
callq 0x9ae0
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::RtConverter(int, unsigned int, bamboo::RtConverter::ConvType)
RtConverter::RtConverter(int delay,unsigned int port_in, ConvType type_in) {
	initlock(&_mutex);
	obsdelay = delay;
	port = port_in;
	type = type_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x870, %rdi            # imm = 0x870
callq 0x323c0
movq -0x20(%rbp), %rdi
addq $0xa0ec8, %rdi          # imm = 0xA0EC8
callq 0x54060
movq -0x20(%rbp), %rdi
addq $0xa0ee0, %rdi          # imm = 0xA0EE0
callq 0x54080
movq -0x20(%rbp), %rdi
addq $0xa0f10, %rdi          # imm = 0xA0F10
callq 0x540a0
movq -0x20(%rbp), %rdi
addq $0xa0f40, %rdi          # imm = 0xA0F40
xorl %eax, %eax
movl %eax, %esi
callq 0x9ae0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::beginProcess()
void RtConverter::beginProcess() {
	def_thread_t pid_handle;
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthProcess_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthProcess, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x41(%rip), %rdx        # 0x51ef0
callq 0x9dc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x51ee8
movq 0xa50fd(%rip), %rdi     # 0xf6fc0
leaq 0x6bb51(%rip), %rsi     # 0xbda1b
callq 0x9760
movq %rax, %rdi
movq 0xa50c7(%rip), %rsi     # 0xf6fa0
callq 0x97c0
movl $0x1, %edi
callq 0x9910
addq $0x10, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::s_pthProcess(void*)
void* RtConverter::s_pthProcess(void* args) {
	RtConverter* svr = (RtConverter*)args;
	if(svr->type == ConvType::obsbnc || svr->type == ConvType::obsbin)
		svr->routineObs();
	else
		svr->routineEph();
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x51f18
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x51f23
movq -0x10(%rbp), %rdi
callq 0x51f40
jmp 0x51f2c
movq -0x10(%rbp), %rdi
callq 0x52690
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::makeupTimeBuffer(bamboo::gtime_t, char*, int&)
void RtConverter::makeupTimeBuffer(gtime_t tt, char* buffin, int& nbyte) {
	int week;
	double sow;
	sow = time2gpst(tt, &week);
	sprintf(buffin, "> %04d %14.7lf\r\n", week, sow);
	nbyte = strlen(buffin);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
leaq -0x2c(%rbp), %rsi
callq 0x8e540
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %edx
movsd -0x38(%rbp), %xmm0
leaq 0x6b263(%rip), %rsi     # 0xbdc8a
movb $0x1, %al
callq 0x9150
movq -0x20(%rbp), %rdi
callq 0x92e0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::makeupEphBuffer_R(bamboo::GLSEPH&, char*, int&)
void RtConverter::makeupEphBuffer_R(GLSEPH& glsEph, char* buffin, int& nbyte) {
	int iy, im, id, ih, imin, isys;
	double sec;
	mjd2date(glsEph.mjd, glsEph.sod, &iy, &im, &id, &ih, &imin, &sec);
	sprintf(buffin + strlen(buffin), "%3s %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\r\n", glsEph.cprn, iy, im, id, ih, imin, (int)sec, glsEph.tau, glsEph.gamma, glsEph.tk);
	sprintf(buffin + strlen(buffin), "    %19.12e%19.12e%19.12e%19.12e\r\n", glsEph.pos[0], glsEph.vel[0],glsEph.acc[0], glsEph.health);
	sprintf(buffin + strlen(buffin), "    %19.12e%19.12e%19.12e%19.12e\r\n", glsEph.pos[1], glsEph.vel[1],glsEph.acc[1], glsEph.frenum);
	sprintf(buffin + strlen(buffin), "    %19.12e%19.12e%19.12e%19.12e\r\n", glsEph.pos[2], glsEph.vel[2],glsEph.acc[2], glsEph.age);
	nbyte = strlen(buffin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x34(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x33420
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movq -0x60(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movl -0x30(%rbp), %r11d
movl -0x34(%rbp), %r10d
cvttsd2si -0x40(%rbp), %eax
movq -0x10(%rbp), %rsi
movsd 0x18(%rsi), %xmm0
movq -0x10(%rbp), %rsi
movsd 0x20(%rsi), %xmm1
movq -0x10(%rbp), %rsi
movsd 0x28(%rsi), %xmm2
leaq 0x6a027(%rip), %rsi     # 0xbdcb9
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x3, %al
callq 0x9150
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movq -0x58(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x48(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x60(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x78(%rax), %xmm3
leaq 0x6a009(%rip), %rsi     # 0xbdcf2
movb $0x4, %al
callq 0x9150
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movq -0x50(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x68(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x80(%rax), %xmm3
leaq 0x69fbc(%rip), %rsi     # 0xbdcf2
movb $0x4, %al
callq 0x9150
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movq -0x48(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x58(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x70(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x88(%rax), %xmm3
leaq 0x69f6f(%rip), %rsi     # 0xbdcf2
movb $0x4, %al
callq 0x9150
movq -0x18(%rbp), %rdi
callq 0x92e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::input_bnx(bamboo::raw_t*, unsigned char)
extern int input_bnx(raw_t *raw, unsigned char data)
{
    unsigned int len;
    int len_h,len_c;
    
    trace(5,"input_bnx: data=%02x\n",data);
    
    /* synchronize binex message */
    if (raw->nbyte==0) {
        if (!sync_bnx(raw->buff,data)) return 0;
        raw->nbyte=2;
        return 0;
    }
    raw->buff[raw->nbyte++]=data;
    if (raw->nbyte<4) return 0;
    
    len_h=getbnxi(raw->buff+2,&len);
    
    raw->len=len+len_h+2; /* length without crc */
    
    if (raw->len-1>4096) {
        trace(2,"binex length error: len=%d\n",raw->len-1);
        raw->nbyte=0;
        return -1;
    }
    len_c=raw->len-1<128?1:2;
    
    if (raw->nbyte<(int)(raw->len+len_c)) return 0;
    raw->nbyte=0;
    
    /* decode binex message */
    return decode_bnx(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edx
movl $0x5, %edi
leaq 0x6370e(%rip), %rsi     # 0xbe1c0
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
cmpl $0x0, 0x81a74(%rax)
jne 0x5ab05
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
movzbl -0x11(%rbp), %esi
callq 0x5ac30
cmpl $0x0, %eax
jne 0x5aaeb
movl $0x0, -0x4(%rbp)
jmp 0x5ac1e
movq -0x10(%rbp), %rax
movl $0x2, 0x81a74(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5ac1e
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x81a74(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x81a74(%rsi)
movslq %ecx, %rcx
movb %dl, 0x81a90(%rax,%rcx)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x81a74(%rax)
jge 0x5ab44
movl $0x0, -0x4(%rbp)
jmp 0x5ac1e
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
addq $0x2, %rdi
leaq -0x18(%rbp), %rsi
callq 0x5ad00
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x81a78(%rax)
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %eax
subl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x5abbd
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %edx
subl $0x1, %edx
movl $0x2, %edi
leaq 0x63637(%rip), %rsi     # 0xbe1d6
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
movl $0x0, 0x81a74(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5ac1e
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %edx
subl $0x1, %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x80, %edx
cmovll %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x81a74(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x81a78(%rcx), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5ac04
movl $0x0, -0x4(%rbp)
jmp 0x5ac1e
movq -0x10(%rbp), %rax
movl $0x0, 0x81a74(%rax)
movq -0x10(%rbp), %rdi
callq 0x5ada0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::sync_bnx(unsigned char*, unsigned char)
static int sync_bnx(unsigned char *buff, unsigned char data)
{
    buff[0]=buff[1]; buff[1]=data;
    
    return buff[0]==BNXSYNC2&&
           (buff[1]==0x00||buff[1]==0x01||buff[1]==0x02||buff[1]==0x03||
            buff[1]==0x7D||buff[1]==0x7E||buff[1]==0x7F);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xe2, %ecx
movb %al, -0xa(%rbp)
jne 0x5acf0
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x3, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7d, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0xb(%rbp)
je 0x5acea
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7f, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::getbnxi(unsigned char*, unsigned int*)
static int getbnxi(unsigned char *p, unsigned int *val)
{
    int i;
    
    for (*val=0,i=0;i<3;i++) {
        *val=(*val<<7)+(p[i]&0x7F);
        if (!(p[i]&0x80)) return i+1;
    }
    *val=(*val<<8)+p[i];
    return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x5ad71
movq -0x18(%rbp), %rax
movl (%rax), %ecx
shll $0x7, %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movzbl (%rax,%rdx), %eax
andl $0x7f, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x5ad64
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5ad95
jmp 0x5ad66
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ad1d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movzbl (%rax,%rdx), %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::csum8(unsigned char const*, int)
static unsigned char csum8(const unsigned char *buff, int len)
{
    unsigned char cs=0;
    int i;
    
    for (i=0;i<len;i++) {
        cs^=buff[i];
    }
    return cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5b29e
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movzbl -0xd(%rbp), %eax
xorl %ecx, %eax
movb %al, -0xd(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b276
movb -0xd(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::adjweek(bamboo::gtime_t, double)
static gtime_t adjweek(gtime_t time, double tow)
{
    double tow_p;
    int week;
    tow_p=time2gpst(time,&week);
    if      (tow<tow_p-302400.0) tow+=604800.0;
    else if (tow>tow_p+302400.0) tow-=604800.0;
    return gpst2time(week,tow);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
leaq -0x34(%rbp), %rsi
callq 0x8e540
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x5e3d1(%rip), %xmm2    # 0xbdd60
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5f9ad
movsd 0x5e3c7(%rip), %xmm0    # 0xbdd68
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x5f9dd
movsd -0x28(%rbp), %xmm0
movsd 0x5e3a6(%rip), %xmm1    # 0xbdd60
addsd -0x30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5f9db
movsd -0x28(%rbp), %xmm0
movsd 0x5e396(%rip), %xmm1    # 0xbdd68
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x5f9dd
movl -0x34(%rbp), %edi
movsd -0x28(%rbp), %xmm0
callq 0x8e4a0
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::adjday(bamboo::gtime_t, double)
static gtime_t adjday(gtime_t time, double tod)
{
    double ep[6],tod_p;
    time2epoch(time,ep);
    tod_p=ep[3]*3600.0+ep[4]*60.0+ep[5];
    if      (tod<tod_p-43200.0) tod+=86400.0;
    else if (tod>tod_p+43200.0) tod-=86400.0;
    ep[3]=ep[4]=ep[5]=0.0;
    return timeadd(epoch2time(ep),tod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdi
movsd -0x70(%rbp), %xmm0
callq 0x8e2f0
movsd -0x48(%rbp), %xmm0
movsd 0x5d370(%rip), %xmm1    # 0xbce18
mulsd -0x40(%rbp), %xmm1
movsd 0x5d35b(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x68(%rbp), %xmm0
movsd 0x5e297(%rip), %xmm2    # 0xbdd70
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5faf7
movsd 0x5d335(%rip), %xmm0    # 0xbce20
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x5fb27
movsd -0x28(%rbp), %xmm0
movsd 0x5e26c(%rip), %xmm1    # 0xbdd70
addsd -0x68(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5fb25
movsd -0x28(%rbp), %xmm0
movsd 0x5d304(%rip), %xmm1    # 0xbce20
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x5fb27
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8e180
movq %rax, -0x88(%rbp)
movsd %xmm0, -0x80(%rbp)
movsd -0x28(%rbp), %xmm1
movq -0x88(%rbp), %rdi
movsd -0x80(%rbp), %xmm0
callq 0x8e860
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::sisaindex(double)
static int sisaindex(double value)
{
    if (value< 0.5) return (int)((value    )/0.01);
    if (value< 1.0) return (int)((value-0.5)/0.02)+ 50;
    if (value< 2.0) return (int)((value-1.0)/0.04)+ 75;
    if (value<=6.0) return (int)((value-2.0)/0.16)+100;
    return 255; /* NAPA */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd 0x5d2df(%rip), %xmm0    # 0xbce80
ucomisd -0x10(%rbp), %xmm0
jbe 0x5fbc5
movsd -0x10(%rbp), %xmm0
movsd 0x5dbd3(%rip), %xmm1    # 0xbd788
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0x5fc74
movsd 0x5c293(%rip), %xmm0    # 0xbbe60
ucomisd -0x10(%rbp), %xmm0
jbe 0x5fbfd
movsd -0x10(%rbp), %xmm0
movsd 0x5d29f(%rip), %xmm1    # 0xbce80
subsd %xmm1, %xmm0
movsd 0x5e19b(%rip), %xmm1    # 0xbdd88
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x32, %eax
movl %eax, -0x4(%rbp)
jmp 0x5fc74
movsd 0x5db4b(%rip), %xmm0    # 0xbd750
ucomisd -0x10(%rbp), %xmm0
jbe 0x5fc35
movsd -0x10(%rbp), %xmm0
movsd 0x5c247(%rip), %xmm1    # 0xbbe60
subsd %xmm1, %xmm0
movsd 0x5e15b(%rip), %xmm1    # 0xbdd80
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x4b, %eax
movl %eax, -0x4(%rbp)
jmp 0x5fc74
movsd 0x5d333(%rip), %xmm0    # 0xbcf70
ucomisd -0x10(%rbp), %xmm0
jb 0x5fc6d
movsd -0x10(%rbp), %xmm0
movsd 0x5daff(%rip), %xmm1    # 0xbd750
subsd %xmm1, %xmm0
movsd 0x5e11b(%rip), %xmm1    # 0xbdd78
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x64, %eax
movl %eax, -0x4(%rbp)
jmp 0x5fc74
movl $0xff, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::lambda(int, int, double const*, double const*, double*, double*)
extern int lambda(int n, int m, const double *a, const double *Q, double *F,
                  double *s)
{
    int info;
    double *L,*D,*Z,*z,*E;
    
    if (n<=0||m<=0) return -1;
    L=zeros(n,n); D=mat(n,1); Z=eye(n); z=mat(n,1); E=mat(n,m);
    
    /* LD factorization */
    if (!(info=LD(n,Q,L,D))) {
        
        /* lambda reduction */
        reduction(n,L,D,Z);
        matmul("TN",n,1,n,1.0,Z,a,0.0,z); /* z=Z'*a */
        
        /* mlambda search */
        if (!(info=search(n,m,L,D,z,E,s))) {
            
            info=solve("T",Z,E,n,m,F); /* F=Z'\E */
        }
    }
    free(L); free(D); free(Z); free(z); free(E);
    return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x6136a
cmpl $0x0, -0xc(%rbp)
jg 0x61376
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x614aa
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x8c6e0
movq %rax, -0x40(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x8c500
movq %rax, -0x48(%rbp)
movl -0x8(%rbp), %edi
callq 0x8c750
movq %rax, -0x50(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x8c500
movq %rax, -0x58(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8c500
movq %rax, -0x60(%rbp)
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x614c0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0x61477
movl -0x8(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x61710
movl -0x8(%rbp), %esi
movl -0x8(%rbp), %ecx
movq -0x50(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x58(%rbp), %rax
leaq 0x5d9d9(%rip), %rdi     # 0xbede8
movl $0x1, %edx
movsd 0x5aa44(%rip), %xmm0    # 0xbbe60
xorps %xmm1, %xmm1
movq %rax, (%rsp)
callq 0x8ca20
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x61850
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0x61475
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
movq -0x28(%rbp), %r9
leaq 0x6a36f(%rip), %rdi     # 0xcb7dc
callq 0x8d4e0
movl %eax, -0x34(%rbp)
jmp 0x61477
movq -0x40(%rbp), %rdi
callq 0x9900
movq -0x48(%rbp), %rdi
callq 0x9900
movq -0x50(%rbp), %rdi
callq 0x9900
movq -0x58(%rbp), %rdi
callq 0x9900
movq -0x60(%rbp), %rdi
callq 0x9900
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::reduction(int, double*, double*, double*)
static void reduction(int n, double *L, double *D, double *Z)
{
    int i,j,k;
    double del;
    
    j=n-2; k=n-2;
    while (j>=0) {
        if (j<=k) for (i=j+1;i<n;i++) gauss(n,L,Z,i,j);
        del=D[j]+L[j+1+j*n]*L[j+1+j*n]*D[j+1];
        if (del+1E-6<D[j+1]) { /* compared considering numerical error */
            perm(n,L,D,j,del,Z);
            k=j; j=n-2;
        }
        else j--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
movl -0x4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x61842
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jg 0x61780
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6177e
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0x62210
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x61754
jmp 0x61780
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl -0x28(%rbp), %edx
imull -0x4(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl -0x28(%rbp), %edx
imull -0x4(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x5d5e6(%rip), %xmm1    # 0xbedd0
addsd -0x38(%rbp), %xmm1
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x61834
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x28(%rbp), %ecx
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %r8
callq 0x62350
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x6183d
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x61739
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::lambda_reduction(int, double const*, double*)
extern int lambda_reduction(int n, const double *Q, double *Z)
{
    double *L,*D;
    int i,j,info;
    
    if (n<=0) return -1;
    
    L=zeros(n,n); D=mat(n,1);
    
    for (i=0;i<n;i++) for (j=0;j<n;j++) {
        Z[i+j*n]=i==j?1.0:0.0;
    }
    /* LD factorization */
    if ((info=LD(n,Q,L,D))) {
        free(L); free(D);
        return info;
    }
    /* lambda reduction */
    reduction(n,L,D,Z);
     
    free(L); free(D);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x62025
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62124
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x8c6e0
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x8c500
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x620c1
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x620b4
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
movsd 0x59def(%rip), %xmm0    # 0xbbe60
xorps %xmm1, %xmm1
movsd %xmm1, -0x48(%rbp)
cmpl %ecx, %eax
movsd %xmm0, -0x40(%rbp)
je 0x6208c
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %edx
imull -0x8(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6205b
jmp 0x620b6
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6204c
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x614c0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x620f7
movq -0x20(%rbp), %rdi
callq 0x9900
movq -0x28(%rbp), %rdi
callq 0x9900
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x62124
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x61710
movq -0x20(%rbp), %rdi
callq 0x9900
movq -0x28(%rbp), %rdi
callq 0x9900
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::lambda_search(int, int, double const*, double const*, double*, double*)
extern int lambda_search(int n, int m, const double *a, const double *Q,
                         double *F, double *s)
{
    double *L,*D;
    int info;
    
    if (n<=0||m<=0) return -1;
    
    L=zeros(n,n); D=mat(n,1);
    
    /* LD factorization */
    if ((info=LD(n,Q,L,D))) {
        free(L); free(D);
        return info;
    }
    /* mlambda search */
    info=search(n,m,L,D,a,F,s);
    
    free(L); free(D);
    return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x6215a
cmpl $0x0, -0xc(%rbp)
jg 0x62166
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x621fa
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x8c6e0
movq %rax, -0x38(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x8c500
movq %rax, -0x40(%rbp)
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x614c0
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x621bc
movq -0x38(%rbp), %rdi
callq 0x9900
movq -0x40(%rbp), %rdi
callq 0x9900
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x621fa
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x61850
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9900
movq -0x40(%rbp), %rdi
callq 0x9900
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)