LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_closeLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_closeLog(string filname){
	map<string, LogItem*>::iterator itr;
	itr = mapOut.find(string(filname));
	def_lock(&_lock);
	if (itr != mapOut.end()) {
		(*(*itr).second).of->flush();
		(*(*itr).second).of->close();
		delete (*itr).second->of;
		delete (*itr).second;
		mapOut.erase(itr);
	}
	map<string,map<string,unsigned int> >::iterator iTtr;
	iTtr = mtimeLog.find(filname);
	if(iTtr != mtimeLog.end()){
		mtimeLog.erase(iTtr);
	}
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x1143c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x226ac
movq %rax, %r12
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x21d3d
callq 0x85d0
leaq 0x60(%rbx), %r15
movq %r15, %rdi
callq 0x8910
leaq 0x8(%rbx), %rax
cmpq %rax, %r12
je 0x21d99
movq 0x40(%r12), %rax
movq (%rax), %rdi
callq 0x8450
movq 0x40(%r12), %rax
movq (%rax), %rdi
callq 0x88a0
movq 0x40(%r12), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x21d7f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0x21d8e
callq 0x85d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2266c
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x22946
addq $0x38, %rbx
cmpq %rbx, %rax
je 0x21dbc
movq %r12, %rdi
movq %rax, %rsi
callq 0x229e4
movq %r15, %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x21de4
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_tmeTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_tmeTag(string filName,string tag){
	unsigned int tt = tickget();
	map<string,map<string,unsigned int> >::iterator itr;
	def_lock(&_lock);
	itr = mtimeLog.find(filName);
	if(itr == mtimeLog.end()){
		map<string,unsigned int> tmp;
		tmp.insert(make_pair(tag, tt));
		mtimeLog.insert(make_pair(filName,tmp));
	}
	else
		(*itr).second.insert(make_pair(tag, tt));
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
callq 0x5088f
movl %eax, -0x2c(%rbp)
leaq 0x60(%r12), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8910
leaq 0x30(%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22946
addq $0x38, %r12
cmpq %r12, %rax
je 0x21e8e
movq %rax, %rbx
addq $0x40, %rbx
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x1143c
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a28
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x21f49
callq 0x85d0
jmp 0x21f49
movq %r15, %r12
movl -0x2c(%rbp), %r15d
leaq -0xb0(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x78(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x1143c
leaq -0x88(%rbp), %rsi
movl %r15d, 0x20(%rsi)
leaq -0xb8(%rbp), %rdi
callq 0x22a28
movq -0x88(%rbp), %rdi
movq %rbx, %r15
cmpq %rbx, %rdi
je 0x21efe
callq 0x85d0
leaq -0x88(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
movq %r14, %rsi
callq 0x223f0
leaq -0x88(%rbp), %rsi
movq %r12, %rdi
callq 0x22c22
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x2223a
movq -0x20(%rbx), %rdi
cmpq %r15, %rdi
je 0x21f3d
callq 0x85d0
leaq -0xb8(%rbp), %rdi
callq 0x2223a
movq -0x38(%rbp), %rdi
callq 0x84b0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2220e
jmp 0x21f93
jmp 0x21f90
movq %rbx, %rcx
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %rcx, %rdi
je 0x21f93
callq 0x85d0
jmp 0x21f93
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x2223a
movq %rbx, %rdi
callq 0x8b40
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x21f9f
callq 0x85d0
jmp 0x21f9f
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Log.cpp
// Function: bamboo::Log::m_tmeConsume(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::m_tmeConsume(string filName,string tag){
	double sec;
	unsigned int tv_end = tickget();
	map<string,map<string,unsigned int> >::iterator itr;
	def_lock(&_lock);
	itr = mtimeLog.find(filName);
	if(itr == mtimeLog.end()){
		cout << "***WARNING(m_tmeConsume) Wrong input FileName!" << endl;
		def_unlock(&_lock);
		return;
	}
	map<string,unsigned int>::iterator sItr;
	sItr = (*itr).second.find(tag);
	if(sItr == (*itr).second.end()){
		cout << "***WARNING(m_tmeConsume) Wrong input Tag!" << endl;
		def_unlock(&_lock);
		return;
	}
	sec = tv_end - (*sItr).second;
	this->m_wtMsg("@%s %s TIME CONSUME %lf\n",filName.c_str(),tag.c_str(),sec / 1000.0);
	(*itr).second.erase(sItr);
	def_unlock(&_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x5088f
movl %eax, %r13d
leaq 0x60(%r14), %rdi
movq %rdi, -0x40(%rbp)
callq 0x8910
leaq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x22946
movq %rax, %r15
leaq 0x38(%r14), %rax
cmpq %rax, %r15
je 0x22060
leaq 0x40(%r15), %rdi
movq %rdi, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
callq 0x22e7c
addq $0x48, %r15
cmpq %r15, %rax
je 0x22075
movq %rax, %rbx
subl 0x40(%rax), %r13d
cvtsi2sd %r13, %xmm0
movq (%r12), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
divsd 0x49437(%rip), %xmm0    # 0x6b478
leaq 0x4955c(%rip), %rsi     # 0x6b5a4
movq %r14, %rdi
movb $0x1, %al
callq 0x21a98
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x22f1a
jmp 0x220b7
movq 0x6bf61(%rip), %rbx     # 0x8dfc8
leaq 0x494dd(%rip), %rsi     # 0x6b54b
movl $0x2e, %edx
jmp 0x22088
movq 0x6bf4c(%rip), %rbx     # 0x8dfc8
leaq 0x494f7(%rip), %rsi     # 0x6b57a
movl $0x29, %edx
movq %rbx, %rdi
callq 0x8730
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8600
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x8450
movq -0x40(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5088f
movl %eax, %r15d
leaq 0x6dda2(%rip), %rdi     # 0x8ff08
movq %r14, %rsi
callq 0x22e7c
movq %rax, %rbx
leaq 0x6dd98(%rip), %rax     # 0x8ff10
cmpq %rax, %rbx
je 0x221b8
subl 0x40(%rbx), %r15d
cvtsi2sd %r15, %xmm0
movq (%r14), %rsi
divsd 0x492e7(%rip), %xmm0    # 0x6b478
leaq 0x4944f(%rip), %rdi     # 0x6b5e7
movb $0x1, %al
callq 0x8080
leaq 0x6dd62(%rip), %rdi     # 0x8ff08
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f1a
movq 0x6be09(%rip), %rbx     # 0x8dfc8
leaq 0x493f7(%rip), %rsi     # 0x6b5bd
movl $0x29, %edx
movq %rbx, %rdi
callq 0x8730
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8600
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8450
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xc800, %edx           # imm = 0xC800
xorl %esi, %esi
callq 0x8390
movl $0x64, 0xc804(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22f8a
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxobs/Patterns.cpp
// Function: bamboo::Patterns::readFile()
void Patterns::readFile(){
	nfile = 0;
	strcpy(fname[nfile], "rnxo");
	strcpy(fform[nfile++], "-STANAM--DDD-0.-YY-o");
	strcpy(fname[nfile], "rnxn");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-n");
	strcpy(fname[nfile], "rnxg");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-g");
	strcpy(fname[nfile], "rnxl");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-l");
	strcpy(fname[nfile], "rnxb");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-b");
	strcpy(fname[nfile], "rnxc");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-c");
	strcpy(fname[nfile], "rnxq");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-q");
	strcpy(fname[nfile], "rnxp");
	strcpy(fform[nfile++], "-brd0--DDD-0.-YY-p");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movb %al, 0x4(%rdi)
movl $0x6f786e72, (%rdi)     # imm = 0x6F786E72
movups 0x48669(%rip), %xmm0    # 0x6b609
movups %xmm0, 0x6400(%rdi)
movabsq $0x6f2d59592d2e30, %rcx # imm = 0x6F2D59592D2E30
movq %rcx, 0x640d(%rdi)
movb %al, 0x104(%rdi)
movl $0x6e786e72, 0x100(%rdi) # imm = 0x6E786E72
movups 0x48654(%rip), %xmm0    # 0x6b623
movups %xmm0, 0x6500(%rdi)
movl $0x6e2d59, 0x650f(%rdi) # imm = 0x6E2D59
movb %al, 0x204(%rdi)
movl $0x67786e72, 0x200(%rdi) # imm = 0x67786E72
movups 0x48644(%rip), %xmm0    # 0x6b63b
movups %xmm0, 0x6600(%rdi)
movl $0x672d59, 0x660f(%rdi) # imm = 0x672D59
movb %al, 0x304(%rdi)
movl $0x6c786e72, 0x300(%rdi) # imm = 0x6C786E72
movl $0x4, 0xc800(%rdi)
movups 0x4862a(%rip), %xmm0    # 0x6b653
movups %xmm0, 0x6700(%rdi)
movl $0x6c2d59, 0x670f(%rdi) # imm = 0x6C2D59
movb %al, 0x404(%rdi)
movl $0x62786e72, 0x400(%rdi) # imm = 0x62786E72
movl $0x5, 0xc800(%rdi)
movups 0x48610(%rip), %xmm0    # 0x6b66b
movups %xmm0, 0x6800(%rdi)
movl $0x622d59, 0x680f(%rdi) # imm = 0x622D59
movb %al, 0x504(%rdi)
movl $0x63786e72, 0x500(%rdi) # imm = 0x63786E72
movl $0x6, 0xc800(%rdi)
movups 0x485f6(%rip), %xmm0    # 0x6b683
movups %xmm0, 0x6900(%rdi)
movl $0x632d59, 0x690f(%rdi) # imm = 0x632D59
movb %al, 0x604(%rdi)
movl $0x71786e72, 0x600(%rdi) # imm = 0x71786E72
movl $0x7, 0xc800(%rdi)
movups 0x485dc(%rip), %xmm0    # 0x6b69b
movups %xmm0, 0x6a00(%rdi)
movl $0x712d59, 0x6a0f(%rdi) # imm = 0x712D59
movb %al, 0x704(%rdi)
movl $0x70786e72, 0x700(%rdi) # imm = 0x70786E72
movl $0x8, 0xc800(%rdi)
movups 0x485c2(%rip), %xmm0    # 0x6b6b3
movups %xmm0, 0x6b00(%rdi)
movl $0x702d59, 0x6b0f(%rdi) # imm = 0x702D59
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, %rbx
leaq -0x2060(%rbp), %r14
movq %r14, %rdi
callq 0x2af0e
leaq 0x69709(%rip), %r15     # 0x8ff58
movl $0x6b0, %r12d           # imm = 0x6B0
movl $0x6b0, %edx            # imm = 0x6B0
movq %r15, %rdi
movq %r14, %rsi
callq 0x84f0
leaq (%r15,%r12), %rdi
leaq (%r12,%rbp), %rsi
addq $-0x2060, %rsi          # imm = 0xDFA0
callq 0x8380
addq $0x20, %r12
cmpq $0x1bf0, %r12           # imm = 0x1BF0
jne 0x26865
movq -0x470(%rbp), %rax
movq -0x468(%rbp), %rsi
movq %rax, 0x6b2ad(%rip)     # 0x91b48
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r14,%rdi), %rdx
addq %r15, %rdi
callq 0x28156
movl $0x1c10, %edi           # imm = 0x1C10
leaq (%r14,%rdi), %rsi
addq %r15, %rdi
callq 0x2839e
movl $0x1c40, %eax           # imm = 0x1C40
leaq (%r14,%rax), %rsi
addq %rax, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
callq 0x84f0
movq %r14, %rdi
callq 0x2aec0
movb $0x1, 0x20(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x85b0
leaq 0x64(%rip), %rdx        # 0x26956
leaq -0x2060(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x8bc0
testl %eax, %eax
jne 0x26917
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x676aa(%rip), %rdi     # 0x8dfc8
leaq 0x4511c(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
jmp 0x2693e
movq %rax, %rbx
leaq -0x2060(%rbp), %rdi
callq 0x2aec0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2068(%rbp), %r15
movq %r15, %rdi
callq 0x2af0e
leaq 0x695c4(%rip), %r12     # 0x8ff58
movl $0x6b0, %r13d           # imm = 0x6B0
movl $0x6b0, %edx            # imm = 0x6B0
movq %r12, %rdi
movq %r15, %rsi
callq 0x84f0
leaq (%r12,%r13), %rdi
leaq -0x2068(,%r13), %rsi
addq %rbp, %rsi
callq 0x8380
addq $0x20, %r13
cmpq $0x1bf0, %r13           # imm = 0x1BF0
jne 0x269aa
movq -0x478(%rbp), %rax
movq -0x470(%rbp), %rsi
movq %rax, 0x6b168(%rip)     # 0x91b48
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r15,%rdi), %rdx
addq %r12, %rdi
callq 0x28156
movl $0x1c10, %edi           # imm = 0x1C10
leaq (%r15,%rdi), %rsi
addq %r12, %rdi
callq 0x2839e
movl $0x1c40, %eax           # imm = 0x1C40
leaq (%r15,%rax), %rsi
addq %rax, %r12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
callq 0x84f0
movq %r15, %rdi
callq 0x2aec0
movb $0x1, 0x20(%r14)
leaq 0x40(%r14), %rdi
callq 0x85b0
leaq -0xe2(%rip), %rdx       # 0x26956
leaq -0x2068(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x8bc0
testl %eax, %eax
jne 0x26a76
addq $0x28, %r14
cmpq %rbx, %r14
je 0x26a64
movq (%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x28e90
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6754b(%rip), %rdi     # 0x8dfc8
leaq 0x44fbd(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
jmp 0x26a9d
movq %rax, %rbx
leaq -0x2068(%rbp), %rdi
callq 0x2aec0
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/RtConverter/Deploy.cpp
// Function: bamboo::Deploy::Deploy(int, char**)
Deploy::Deploy(int nargc,char* args[]) {
	/// using init value 
	int iargc;
	lastAct = 0;
	ephport = -1;
	if (s_count++ == 0)
		def_initlock(&s_mutex);
	for (iargc = 0; iargc < nargc; iargc++) {
		if (!strcmp(args[iargc], "-h") || !strcmp(args[iargc], "-help")) {
			cout << "Usage:RtConverter -conf configures.json" << endl;
			exit(1);
		}
		if (!strcmp(args[iargc], "-conf")) {
			strcpy(f_jsonConfigures, args[++iargc]);
		}
	}
	this->m_readConfiguresJson(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
movl $0x6c0, %eax            # imm = 0x6C0
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
movq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x1c00, %rax           # imm = 0x1C00
jne 0x2991f
leaq 0x1bf8(%rbx), %rax
movq %rax, 0x1c00(%rbx)
movq %rax, -0x40(%rbp)
movq %rax, 0x1bf8(%rbx)
xorl %eax, %eax
movq %rax, 0x1c08(%rbx)
leaq 0x1c18(%rbx), %rcx
movl $0x0, 0x1c18(%rbx)
movq %rax, 0x1c20(%rbx)
movq %rcx, 0x1c28(%rbx)
movq %rcx, 0x1c30(%rbx)
movq %rax, 0x1c38(%rbx)
movq %rax, 0x1bf0(%rbx)
movl $0xffffffff, 0x58(%rbx) # imm = 0xFFFFFFFF
movl 0x68604(%rip), %eax     # 0x91fa8
leal 0x1(%rax), %ecx
movl %ecx, 0x685fb(%rip)     # 0x91fa8
testl %eax, %eax
jne 0x299bf
leaq 0x685f8(%rip), %rdi     # 0x91fb0
xorl %esi, %esi
callq 0x8920
leaq 0x1c10(%rbx), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x29a3a
leaq 0x1c40(%rbx), %rax
movq %rax, -0x48(%rbp)
xorl %r14d, %r14d
movslq %r14d, %r12
movq (%r15,%r12,8), %r13
movq %r13, %rdi
leaq 0x42095(%rip), %rsi     # 0x6ba84
callq 0x8890
testl %eax, %eax
je 0x29a56
movq %r13, %rdi
leaq 0x42085(%rip), %rsi     # 0x6ba87
callq 0x8890
testl %eax, %eax
je 0x29a56
movq %r13, %rdi
leaq 0x420a0(%rip), %rsi     # 0x6bab5
callq 0x8890
testl %eax, %eax
jne 0x29a31
leal 0x1(%r12), %r14d
movq 0x8(%r15,%r12,8), %rsi
movq -0x48(%rbp), %rdi
callq 0x85c0
incl %r14d
cmpl -0x2c(%rbp), %r14d
jl 0x299de
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29aaa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6456b(%rip), %rdi     # 0x8dfc8
leaq 0x42029(%rip), %rsi     # 0x6ba8d
movl $0x27, %edx
callq 0x8730
movq 0x64553(%rip), %rdi     # 0x8dfc8
callq 0x8300
movl $0x1, %edi
callq 0x87c0
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2b2d2
movq -0x40(%rbp), %rdi
callq 0x28358
movq %rbx, %rdi
callq 0x8e4f
movq %r14, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x6c0, %eax            # imm = 0x6C0
leaq (%rdi,%rax), %rcx
movq %rcx, -0x10(%rdi,%rax)
movq $0x0, -0x8(%rdi,%rax)
movb $0x0, (%rdi,%rax)
addq $0x20, %rax
cmpq $0x1c00, %rax           # imm = 0x1C00
jne 0x2ae21
leaq 0x1bf8(%rdi), %rax
movq %rax, 0x1c00(%rdi)
movq %rax, 0x1bf8(%rdi)
xorl %eax, %eax
movq %rax, 0x1c08(%rdi)
leaq 0x1c18(%rdi), %rcx
movl $0x0, 0x1c18(%rdi)
movq %rax, 0x1c20(%rdi)
movq %rcx, 0x1c28(%rdi)
movq %rcx, 0x1c30(%rdi)
movq %rax, 0x1c38(%rdi)
movq %rax, 0x1bf0(%rdi)
movl $0xffffffff, 0x58(%rdi) # imm = 0xFFFFFFFF
movl 0x67106(%rip), %eax     # 0x91fa8
leal 0x1(%rax), %ecx
movl %ecx, 0x670fd(%rip)     # 0x91fa8
testl %eax, %eax
je 0x2aeb1
popq %rbp
retq
leaq 0x670f8(%rip), %rdi     # 0x91fb0
xorl %esi, %esi
popq %rbp
jmp 0x8920
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6708e(%rip), %rdi     # 0x91fb0
callq 0x8910
movq %rbx, %rdi
callq 0x2ae18
movq 0x6706a(%rip), %r14     # 0x91fa0
movl $0x6b0, %r15d           # imm = 0x6B0
movl $0x6b0, %edx            # imm = 0x6B0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84f0
leaq (%rbx,%r15), %rdi
leaq (%r14,%r15), %rsi
callq 0x8380
addq $0x20, %r15
cmpq $0x1bf0, %r15           # imm = 0x1BF0
jne 0x2af4c
movq 0x1bf0(%r14), %rax
movq %rax, 0x1bf0(%rbx)
cmpq %rbx, %r14
je 0x2af91
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x1bf8(%r14), %rsi
callq 0x28156
movl $0x1c10, %esi           # imm = 0x1C10
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x2839e
movl $0x1c40, %eax           # imm = 0x1C40
movq %rbx, %rdi
addq %rax, %rdi
addq %rax, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
callq 0x84f0
leaq 0x66fec(%rip), %rdi     # 0x91fb0
callq 0x84b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2afd9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2aec0
movq %r14, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x98, %rsp
movl $0x1c40, %edi           # imm = 0x1C40
addq 0x66f9c(%rip), %rdi     # 0x91fa0
leaq -0x98(%rbp), %rsi
callq 0x8580
movq 0x66f89(%rip), %rsi     # 0x91fa0
testl %eax, %eax
je 0x2b034
addq $0x1c40, %rsi           # imm = 0x1C40
leaq 0x40a92(%rip), %rdi     # 0x6babb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8080
jmp 0x2b06b
movq 0x1bf0(%rsi), %rax
cmpq -0x40(%rbp), %rax
setne %bl
je 0x2b06b
leaq 0x66f65(%rip), %rbx     # 0x91fb0
movq %rbx, %rdi
callq 0x8910
movq 0x66f46(%rip), %rdi     # 0x91fa0
xorl %esi, %esi
callq 0x29aaa
movq %rbx, %rdi
callq 0x84b0
movb $0x1, %bl
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/RtConverter/Deploy.cpp
// Function: bamboo::Deploy::m_checkStation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Deploy::m_checkStation(string sta) {
	list<string>::iterator strItr;
	list<VrsStaItem>::iterator itemItr;
	map<string, list<VrsStaItem>>::iterator mapItr;
	/// should check more precisely
	transform(sta.begin(), sta.end(), sta.begin(), ::toupper);
	for (strItr = post_stalist.begin(); strItr != post_stalist.end(); strItr++) {
		string value = (*strItr);
		transform(value.begin(), value.end(), value.begin(), ::toupper);
		if (!strncmp(sta.c_str(), value.c_str(), 4)) return false;
	}
	for (mapItr = rt_mounts.begin(); mapItr != rt_mounts.end(); mapItr++) {
		for (itemItr = (*mapItr).second.begin(); itemItr != (*mapItr).second.end(); ++itemItr) {
			string value = (*itemItr).staname;
			transform(value.begin(), value.end(), value.begin(), ::toupper);
			if (!strncmp(sta.c_str(), value.c_str(), 4)) return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0x2b0ba
movq -0x38(%rbp), %rax
movq (%rax), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x8bf0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x2b0a4
movq -0x30(%rbp), %rax
leaq 0x1bf8(%rax), %r15
leaq -0x48(%rbp), %rbx
movq %r15, %r14
movq (%r14), %r14
cmpq %r15, %r14
je 0x2b159
movq %rbx, -0x58(%rbp)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x1143c
movq -0x50(%rbp), %r12
testq %r12, %r12
je 0x2b117
movq -0x58(%rbp), %r13
xorl %ebx, %ebx
movsbl (%r13,%rbx), %edi
callq 0x8bf0
movb %al, (%r13,%rbx)
incq %rbx
cmpq %rbx, %r12
jne 0x2b0ff
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x58(%rbp), %r12
movl $0x4, %edx
movq %r12, %rsi
callq 0x82f0
movl %eax, %r13d
leaq -0x48(%rbp), %rbx
cmpq %rbx, %r12
je 0x2b143
movq %r12, %rdi
callq 0x85d0
testl %r13d, %r13d
jne 0x2b0cc
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rcx
movq 0x1c28(%rcx), %rdx
addq $0x1c18, %rcx           # imm = 0x1C18
movb $0x1, %al
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rdx
je 0x2b14a
movq %rdx, -0x60(%rbp)
leaq 0x40(%rdx), %r13
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x2b1ff
movq %rbx, -0x58(%rbp)
movq 0x30(%r12), %rsi
movq 0x38(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x1143c
movq -0x50(%rbp), %r14
testq %r14, %r14
je 0x2b1c9
movq -0x58(%rbp), %r15
xorl %ebx, %ebx
movsbl (%r15,%rbx), %edi
callq 0x8bf0
movb %al, (%r15,%rbx)
incq %rbx
cmpq %rbx, %r14
jne 0x2b1b3
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x58(%rbp), %r15
movl $0x4, %edx
movq %r15, %rsi
callq 0x82f0
movl %eax, %r14d
leaq -0x48(%rbp), %rbx
cmpq %rbx, %r15
je 0x2b1f5
movq %r15, %rdi
callq 0x85d0
testl %r14d, %r14d
jne 0x2b181
jmp 0x2b148
movq -0x60(%rbp), %rdi
callq 0x8460
movq %rax, %rdx
cmpq -0x30(%rbp), %rax
jne 0x2b176
movb $0x1, %al
jmp 0x2b14a
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x870, %rdi            # imm = 0x870
callq 0x1c984
leaq 0xa0ec8(%rbx), %rax
movq %rax, 0xa0ed0(%rbx)
movq %rax, 0xa0ec8(%rbx)
xorl %eax, %eax
movq %rax, 0xa0ed8(%rbx)
leaq 0xa0ee8(%rbx), %rcx
movl %eax, 0xa0ee8(%rbx)
movq %rax, 0xa0ef0(%rbx)
movq %rcx, 0xa0ef8(%rbx)
movq %rcx, 0xa0f00(%rbx)
movq %rax, 0xa0f08(%rbx)
leaq 0xa0f18(%rbx), %rcx
movl %eax, 0xa0f18(%rbx)
movq %rax, 0xa0f20(%rbx)
movq %rcx, 0xa0f28(%rbx)
movq %rcx, 0xa0f30(%rbx)
movq %rax, 0xa0f38(%rbx)
leaq 0xa0f40(%rbx), %rdi
xorl %esi, %esi
callq 0x8920
movq $0x5, (%rbx)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
addq $0x870, %rdi            # imm = 0x870
callq 0x1c984
leaq 0xa0ec8(%r15), %rax
movq %rax, 0xa0ed0(%r15)
movq %rax, 0xa0ec8(%r15)
xorl %eax, %eax
movq %rax, 0xa0ed8(%r15)
leaq 0xa0ee8(%r15), %rcx
movl %eax, 0xa0ee8(%r15)
movq %rax, 0xa0ef0(%r15)
movq %rcx, 0xa0ef8(%r15)
movq %rcx, 0xa0f00(%r15)
movq %rax, 0xa0f08(%r15)
leaq 0xa0f18(%r15), %rcx
movl %eax, 0xa0f18(%r15)
movq %rax, 0xa0f20(%r15)
movq %rcx, 0xa0f28(%r15)
movq %rcx, 0xa0f30(%r15)
movq %rax, 0xa0f38(%r15)
leaq 0xa0f40(%r15), %rdi
xorl %esi, %esi
callq 0x8920
movl %r12d, (%r15)
movl %r14d, 0x8(%r15)
movl %ebx, 0x4(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::inputObs(bamboo::RtConvItem&)
int RtConverter::inputObs(RtConvItem& item) {
	def_lock(&_mutex);
	if (obsqueue.empty()) {
		obsqueue.push_back(item);
		def_unlock(&_mutex);
		return 1;
	}
	RtConvItem& front = this->obsqueue.front();
	RtConvItem& end = this->obsqueue.back();
	if (item.curt.time < front.curt.time) {
		def_unlock(&_mutex);
		return 0;
	}
	if (item.curt.time > end.curt.time) {
		this->obsqueue.push_back(item);
		def_unlock(&_mutex);
		return 1;
	}
	list<RtConvItem>::iterator itrlist;
	for (itrlist = obsqueue.begin(); itrlist != obsqueue.end(); ++itrlist) {
		if (item.curt.time <= (*itrlist).curt.time)
			break;
	}
	if ((*itrlist).curt.time != item.curt.time) {
		obsqueue.insert(itrlist, item);
		def_unlock(&_mutex);
		return 1;
	}
	/// queue already exist the same time,will add into the memory
	std::map<std::string, std::map<std::string, RtSatObs> >::iterator itr, obitr_in = item.obslist.begin();
	std::map<std::string, std::map<std::string, RtSatObs> >::iterator obitr_mem = (*itrlist).obslist.begin();
	while (obitr_in != item.obslist.end()) {
		itr = (*itrlist).obslist.find((*obitr_in).first);
		if (itr != (*itrlist).obslist.end()) {
			++obitr_in;
			continue;
		}
		(*itrlist).obslist[(*obitr_in).first] = (*obitr_in).second;
		++obitr_in;
	}
	def_unlock(&_mutex);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0xa0f40(%rdi), %rbx
movq %rbx, %rdi
callq 0x8910
leaq 0xa0ec8(%r12), %r13
movq 0xa0ec8(%r12), %r15
cmpq %r13, %r15
je 0x2ba35
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpq 0x18(%r15), %rax
jl 0x2ba58
movq 0xa0ed0(%r12), %rcx
cmpq 0x18(%rcx), %rax
jle 0x2ba73
movq %r13, %rdi
movq %r14, %rsi
callq 0x2d222
movq %rax, %rdi
movq %r13, %rsi
callq 0x80c0
incq 0xa0ed8(%r12)
movl $0x1, %ecx
movq %rbx, %rdi
movl %ecx, %ebx
callq 0x84b0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r13, %r15
je 0x2ba83
cmpq 0x18(%r15), %rax
jle 0x2ba83
movq (%r15), %r15
jmp 0x2ba73
cmpq %rax, 0x18(%r15)
jne 0x2baf8
movq 0x30(%r14), %r12
addq $0x20, %r14
movl $0x1, %ecx
cmpq %r14, %r12
je 0x2ba58
movq %rbx, -0x30(%rbp)
leaq 0x28(%r15), %r13
addq $0x30, %r15
movq %r14, -0x38(%rbp)
leaq 0x20(%r12), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2d69c
cmpq %r15, %rax
jne 0x2badf
leaq 0x40(%r12), %r14
movq %r13, %rdi
movq %rbx, %rsi
callq 0x280c2
movq %rax, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %r14
callq 0x289f4
movq %r12, %rdi
callq 0x8460
movq %rax, %r12
cmpq %r14, %rax
jne 0x2baab
movq -0x30(%rbp), %rbx
jmp 0x2ba53
movq %r13, %rdi
movq %r14, %rsi
callq 0x2d222
movq %rax, %rdi
movq %r15, %rsi
jmp 0x2ba46
// File: /workspace/github_cpp_makefile_star2_O1/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, %rcx
leaq 0x3a(%rip), %rdx        # 0x2bb5a
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8bc0
testl %eax, %eax
jne 0x2bb35
addq $0x10, %rsp
popq %rbp
retq
movq 0x6248c(%rip), %rdi     # 0x8dfc8
leaq 0x3fefe(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::routineEph()
void RtConverter::routineEph() {
	time_t now;
	int nbyte;
	char cmd[256];
	unsigned char buff[1024];
	sprintf(cmd, ":%d", port);
	strinit(&svr);
	stropen(&svr, STR_TCPSVR, STR_MODE_RW, cmd);
	while (true) {
		/// here to sending the ephemeris
		def_lock(&_mutex);
		std::map<string, list<GPSEPH> >::iterator mapItr_G;
		std::map<string, list<GLSEPH> >::iterator mapItr_R;
		for (mapItr_G = ephqueue_G.begin(); mapItr_G != ephqueue_G.end(); ++mapItr_G) {
			list<GPSEPH>::iterator ephItr;
			for (ephItr = (*mapItr_G).second.begin(); ephItr != (*mapItr_G).second.end(); ++ephItr) {
				memset(buff, 0, sizeof(buff));
				makeupEphBuffer_G(*ephItr, (char*)buff, nbyte);
				strwrite(&svr, buff, nbyte);
			}
		}
		for (mapItr_R = ephqueue_R.begin(); mapItr_R != ephqueue_R.end(); ++mapItr_R) {
			list<GLSEPH>::iterator ephItr;
			for (ephItr = (*mapItr_R).second.begin(); ephItr != (*mapItr_R).second.end(); ++ephItr) {
				memset(buff, 0, sizeof(buff));
				makeupEphBuffer_R(*ephItr, (char*)buff, nbyte);
				strwrite(&svr, buff, nbyte);
			}
		}
		def_unlock(&_mutex);
		sleepms(5000);
	}
	strclose(&svr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
movq %rdi, %r15
movl 0x8(%rdi), %edx
leaq 0x3fdbb(%rip), %rsi     # 0x6bc88
leaq -0x160(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8120
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x58952
movq %r14, %rdi
movl $0x3, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x589a3
leaq 0xa0f40(%r15), %rbx
leaq 0xa0ee8(%r15), %rax
movq %rax, -0x50(%rbp)
movq %r15, -0x40(%rbp)
leaq 0xa0f18(%r15), %rax
movq %rax, -0x48(%rbp)
leaq -0x560(%rbp), %r12
leaq -0x2c(%rbp), %r13
movq %rbx, -0x58(%rbp)
movq %rbx, %rdi
callq 0x8910
movq -0x40(%rbp), %rax
movq 0xa0ef8(%rax), %rax
cmpq -0x50(%rbp), %rax
je 0x2bf95
leaq 0x40(%rax), %r15
movq %rax, -0x38(%rbp)
movq 0x40(%rax), %rbx
cmpq %r15, %rbx
je 0x2bf8a
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x10(%rbx), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2c83e
movl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5abb7
movq (%rbx), %rbx
jmp 0x2bf54
movq -0x38(%rbp), %rdi
callq 0x8460
jmp 0x2bf42
movq -0x40(%rbp), %rax
movq 0xa0f28(%rax), %rax
cmpq -0x48(%rbp), %rax
je 0x2bff3
leaq 0x40(%rax), %r15
movq %rax, -0x38(%rbp)
movq 0x40(%rax), %rbx
cmpq %r15, %rbx
je 0x2bfe8
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x10(%rbx), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2cad0
movl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5abb7
movq (%rbx), %rbx
jmp 0x2bfb2
movq -0x38(%rbp), %rdi
callq 0x8460
jmp 0x2bfa0
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x84b0
movl $0x1388, %edi           # imm = 0x1388
callq 0x508e9
jmp 0x2bf2f
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x4fc2d
movl (%r15), %edx
leaq 0x3fc83(%rip), %rsi     # 0x6bcba
movq %r14, %rdi
movb $0x1, %al
callq 0x8120
movq %r14, %rdi
callq 0x8290
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/RtConverter/RtConverter.cpp
// Function: bamboo::RtConverter::makeupObsBuffer(char const*, char const*, bamboo::RtSatObs&, char*, int&)
void RtConverter::makeupObsBuffer(const char* sitname, const char* cprn, RtSatObs& obs, char* buffin, int& nbyte) {
	int ifreq, hasobs = false;
	string sit_out = string(sitname);
	transform(sit_out.begin(), sit_out.end(), sit_out.begin(), ::toupper);
	sprintf(buffin, "%s %s", sit_out.c_str(), cprn);
	for (ifreq = 0; ifreq < MAXFREQ; ifreq++) {
		hasobs = false;
		if (obs.obs[ifreq] != 0.0) {
			hasobs = true;
			sprintf(buffin + strlen(buffin), " %s %14.3lf", obs.fob[ifreq].c_str(), obs.obs[ifreq]);
		}
		if (obs.obs[MAXFREQ + ifreq] != 0.0) {
			hasobs = true;
			sprintf(buffin + strlen(buffin), " %s %14.3lf", obs.fob[MAXFREQ + ifreq].c_str(), obs.obs[MAXFREQ + ifreq]);
		}
		if (hasobs) {
			sprintf(buffin + strlen(buffin), " S%s %7.3lf",obs.fob[MAXFREQ + ifreq].c_str() + 1, obs.snr[ifreq]);
		}	
	}
	strcat(buffin, "\r\n");
	nbyte = strlen(buffin);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x40(%rbp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, -0x38(%rbp)
leaq -0x60(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0x8260
movq 0x8(%r13), %rbx
testq %rbx, %rbx
je 0x2c0ad
movq -0x60(%rbp), %r13
xorl %r12d, %r12d
movsbl (%r13,%r12), %edi
callq 0x8bf0
movb %al, (%r13,%r12)
incq %r12
cmpq %r12, %rbx
jne 0x2c095
movq -0x60(%rbp), %rdx
leaq 0x3fc13(%rip), %rsi     # 0x6bccb
movq %r14, %rdi
movq -0x38(%rbp), %rcx
xorl %eax, %eax
callq 0x8120
movl $0x12, %ebx
leaq 0x3fbff(%rip), %r12     # 0x6bcd1
leaq 0x3fc04(%rip), %r13     # 0x6bcdd
movsd -0x12(%r15,%rbx), %xmm0
ucomisd 0x3e820(%rip), %xmm0    # 0x6a908
movl $0x0, %eax
jne 0x2c0f1
jnp 0x2c11a
movq %r14, %rdi
movsd %xmm0, -0x38(%rbp)
callq 0x8290
leaq (%rax,%r14), %rdi
movq (%r15,%rbx,4), %rdx
movq %r12, %rsi
movsd -0x38(%rbp), %xmm0
movb $0x1, %al
callq 0x8120
movl $0x1, %eax
movsd 0x6(%r15,%rbx), %xmm0
ucomisd 0x3e7df(%rip), %xmm0    # 0x6a908
jne 0x2c12d
jnp 0x2c157
movq %r14, %rdi
movsd %xmm0, -0x38(%rbp)
callq 0x8290
leaq (%rax,%r14), %rdi
movq 0x60(%r15,%rbx,4), %rdx
movq %r12, %rsi
movsd -0x38(%rbp), %xmm0
movb $0x1, %al
callq 0x8120
movl $0x1, %eax
testl %eax, %eax
je 0x2c180
movq %r14, %rdi
callq 0x8290
leaq (%rax,%r14), %rdi
movq 0x60(%r15,%rbx,4), %rdx
incq %rdx
movsd 0x1e(%r15,%rbx), %xmm0
movq %r13, %rsi
movb $0x1, %al
callq 0x8120
addq $0x8, %rbx
cmpq $0x2a, %rbx
jne 0x2c0d9
movq %r14, %rdi
callq 0x8290
movw $0xa0d, (%r14,%rax)     # imm = 0xA0D
movb $0x0, 0x2(%r14,%rax)
movq %r14, %rdi
callq 0x8290
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c1c3
callq 0x85d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movl 0x4(%rsi), %edi
movsd 0x10(%rsi), %xmm0
subq $0x8, %rsp
leaq -0x40(%rbp), %rax
leaq -0x4c(%rbp), %r12
leaq -0x48(%rbp), %r13
leaq -0x44(%rbp), %rbx
leaq -0x30(%rbp), %r8
leaq -0x2c(%rbp), %r9
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
pushq %rax
callq 0x1d2d2
addq $0x10, %rsp
movq %r14, %rdi
callq 0x8290
leaq (%rax,%r14), %rdi
movl (%r12), %ecx
movl (%r13), %r8d
movl (%rbx), %r9d
leaq -0x30(%rbp), %rax
movl (%rax), %r10d
leaq -0x40(%rbp), %rax
cvttsd2si (%rax), %r11d
leaq -0x2c(%rbp), %rax
movl (%rax), %ebx
movsd 0x18(%r15), %xmm0
movsd 0x20(%r15), %xmm1
movsd 0x28(%r15), %xmm2
subq $0x8, %rsp
leaq 0x3f17d(%rip), %rsi     # 0x6bce9
movq %r15, %rdx
movb $0x3, %al
pushq %r11
pushq %rbx
pushq %r10
callq 0x8120
addq $0x20, %rsp
movq %r14, %rdi
callq 0x8290
leaq (%rax,%r14), %rdi
movsd 0x30(%r15), %xmm0
movsd 0x48(%r15), %xmm1
movsd 0x60(%r15), %xmm2
movsd 0x78(%r15), %xmm3
leaq 0x3f178(%rip), %r12     # 0x6bd22
movq %r12, %rsi
movb $0x4, %al
callq 0x8120
movq %r14, %rdi
callq 0x8290
leaq (%rax,%r14), %rdi
movsd 0x38(%r15), %xmm0
movsd 0x50(%r15), %xmm1
movsd 0x68(%r15), %xmm2
movsd 0x80(%r15), %xmm3
movq %r12, %rsi
movb $0x4, %al
callq 0x8120
movq %r14, %rdi
callq 0x8290
leaq (%rax,%r14), %rdi
movsd 0x40(%r15), %xmm0
movsd 0x58(%r15), %xmm1
movsd 0x70(%r15), %xmm2
movsd 0x88(%r15), %xmm3
movq %r12, %rsi
movb $0x4, %al
callq 0x8120
movq %r14, %rdi
callq 0x8290
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x3dcd1(%rip), %rsi     # 0x6c028
xorl %r14d, %r14d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4ded0
movslq 0x81a74(%rbx), %rax
testq %rax, %rax
je 0x2e3d2
leal 0x1(%rax), %ecx
movl %ecx, 0x81a74(%rbx)
movb %r15b, 0x81a90(%rbx,%rax)
movl 0x81a74(%rbx), %eax
cmpl $0x4, %eax
jl 0x2e44c
xorl %ecx, %ecx
movl $0x81a92, %edx          # imm = 0x81A92
movl %ecx, %esi
shll $0x7, %esi
movzbl (%rbx,%rdx), %edi
movl %edi, %ecx
andl $0x7f, %ecx
orl %esi, %ecx
testb %dil, %dil
jns 0x2e3f2
incq %rdx
cmpq $0x81a95, %rdx          # imm = 0x81A95
jne 0x2e39c
shll $0x8, %ecx
movzbl 0x81a95(%rbx), %esi
orl %ecx, %esi
movl $0x4, %edx
movl %esi, %ecx
jmp 0x2e3f8
leaq 0x81a90(%rbx), %rdi
movzbl %r15b, %esi
callq 0x2e473
testl %eax, %eax
je 0x2e44c
movl $0x2, 0x81a74(%rbx)
jmp 0x2e44c
addl $0xfff7e56f, %edx       # imm = 0xFFF7E56F
leal (%rdx,%rcx), %esi
addl $0x2, %esi
movl %esi, 0x81a78(%rbx)
addl %ecx, %edx
incl %edx
cmpl $0x1001, %edx           # imm = 0x1001
jl 0x2e435
leaq 0x3dc27(%rip), %rsi     # 0x6c03e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x2e44c
xorl %ecx, %ecx
cmpl $0x80, %edx
setl %cl
subl %ecx, %esi
addl $0x2, %esi
xorl %r14d, %r14d
cmpl %esi, %eax
jge 0x2e45a
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2e4a9
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1(%rdi), %cl
movb %cl, (%rdi)
movb %sil, 0x1(%rdi)
xorl %eax, %eax
cmpb $-0x1e, %cl
jne 0x2e4a7
movl $0x1, %eax
cmpb $0x4, %sil
jb 0x2e4a7
movzbl %sil, %ecx
addl $-0x7d, %ecx
cmpl $0x2, %ecx
jb 0x2e4a7
xorl %eax, %eax
cmpb $0x7f, %sil
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/binex.cpp
// Function: bamboo::input_bnxf(bamboo::raw_t*, _IO_FILE*)
extern int input_bnxf(raw_t *raw, FILE *fp)
{
    unsigned int len;
    int i,data,len_h,len_c;
    
    trace(4,"input_bnxf\n");
    
    if (raw->nbyte==0) {
        for (i=0;;i++) {
            if ((data=fgetc(fp))==EOF) return -2;
            if (sync_bnx(raw->buff,(unsigned char)data)) break;
            if (i>=4096) return 0;
        }
    }
    if (fread(raw->buff+2,1,4,fp)<4) return -2;
    
    len_h=getbnxi(raw->buff+2,&len);
    
    raw->len=len+len_h+2;
    
    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 (fread(raw->buff+6,1,raw->len+len_c-6,fp)<(size_t)(raw->len+len_c-6)) {
        return -2;
    }
    raw->nbyte=0;
    
    /* decode binex message */
    return decode_bnx(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3963c(%rip), %rsi     # 0x6c05a
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
cmpl $0x0, 0x81a74(%rbx)
je 0x32a98
leaq 0x81a92(%rbx), %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x8930
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x4, %rax
jb 0x32b90
xorl %ecx, %ecx
movl $0x81a92, %eax          # imm = 0x81A92
movl %ecx, %edx
shll $0x7, %edx
movzbl (%rbx,%rax), %esi
movl %esi, %ecx
andl $0x7f, %ecx
orl %edx, %ecx
testb %sil, %sil
jns 0x32aea
incq %rax
cmpq $0x81a95, %rax          # imm = 0x81A95
jne 0x32a63
shll $0x8, %ecx
movzbl 0x81a95(%rbx), %edx
orl %ecx, %edx
movl $0x4, %eax
movl %edx, %ecx
jmp 0x32aef
movq %r14, %rdi
callq 0x89d0
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x1, %eax
je 0x32b90
leaq 0x81a90(%rbx), %r12
movl $0x1001, %r13d          # imm = 0x1001
movzbl %al, %esi
movq %r12, %rdi
callq 0x2e473
testl %eax, %eax
jne 0x32a33
decl %r13d
je 0x32b8d
movq %r14, %rdi
callq 0x89d0
cmpl $-0x1, %eax
jne 0x32abc
jmp 0x32b90
addl $0xfff7e56f, %eax       # imm = 0xFFF7E56F
leal (%rax,%rcx), %edx
addl $0x2, %edx
movl %edx, 0x81a78(%rbx)
leal (%rax,%rcx), %edx
incl %edx
cmpl $0x1001, %edx           # imm = 0x1001
jl 0x32b2d
leaq 0x3952f(%rip), %rsi     # 0x6c03e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x32b90
addl %ecx, %eax
xorl %r12d, %r12d
cmpl $0x80, %edx
setge %r12b
leaq 0x81a96(%rbx), %rdi
addl %r12d, %eax
addl $-0x3, %eax
movslq %eax, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x8930
movl 0x81a78(%rbx), %ecx
addl %r12d, %ecx
addl $-0x5, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jb 0x32b90
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e4a9
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/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 $0x10, %rsp
movsd %xmm1, -0x10(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x4fc2d
movsd 0x39210(%rip), %xmm1    # 0x6bdd0
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
jbe 0x32bdd
addsd 0x3920d(%rip), %xmm1    # 0x6bde8
jmp 0x32bf3
addsd 0x391f3(%rip), %xmm0    # 0x6bdd8
ucomisd %xmm0, %xmm1
jbe 0x32bf3
addsd 0x391ed(%rip), %xmm1    # 0x6bde0
movl -0x4(%rbp), %edi
movapd %xmm1, %xmm0
callq 0x4fbc6
addq $0x10, %rsp
popq %rbp
retq