LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fece
movl %eax, %r13d
leaq 0x60(%r14), %rdi
movq %rdi, -0x40(%rbp)
callq 0x8900
leaq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x222da
movq %rax, %r15
leaq 0x38(%r14), %rax
cmpq %rax, %r15
je 0x219fe
leaq 0x40(%r15), %rdi
movq %rdi, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
callq 0x227f4
addq $0x48, %r15
cmpq %r15, %rax
je 0x21a13
movq %rax, %rbx
subl 0x40(%rax), %r13d
cvtsi2sd %r13, %xmm0
movq (%r12), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
divsd 0x49a99(%rip), %xmm0    # 0x6b478
leaq 0x49bbe(%rip), %rsi     # 0x6b5a4
movq %r14, %rdi
movb $0x1, %al
callq 0x21432
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x22892
jmp 0x21a55
movq 0x6c5cb(%rip), %rbx     # 0x8dfd0
leaq 0x49b3f(%rip), %rsi     # 0x6b54b
movl $0x2e, %edx
jmp 0x21a26
movq 0x6c5b6(%rip), %rbx     # 0x8dfd0
leaq 0x49b59(%rip), %rsi     # 0x6b57a
movl $0x29, %edx
movq %rbx, %rdi
callq 0x8720
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_O3/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 0x4fece
movl %eax, %r15d
leaq 0x6e404(%rip), %rdi     # 0x8ff08
movq %r14, %rsi
callq 0x227f4
movq %rax, %rbx
leaq 0x6e3fa(%rip), %rax     # 0x8ff10
cmpq %rax, %rbx
je 0x21b56
subl 0x40(%rbx), %r15d
cvtsi2sd %r15, %xmm0
movq (%r14), %rsi
divsd 0x49949(%rip), %xmm0    # 0x6b478
leaq 0x49ab1(%rip), %rdi     # 0x6b5e7
movb $0x1, %al
callq 0x8080
leaq 0x6e3c4(%rip), %rdi     # 0x8ff08
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22892
movq 0x6c473(%rip), %rbx     # 0x8dfd0
leaq 0x49a59(%rip), %rsi     # 0x6b5bd
movl $0x29, %edx
movq %rbx, %rdi
callq 0x8720
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_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movl $0x64, 0xc804(%rdi)
addq $0x5, %rdi
xorl %r14d, %r14d
movl $0xc7fb, %edx           # imm = 0xC7FB
xorl %esi, %esi
callq 0x8390
movb %r14b, 0x4(%rbx)
movl $0x6f786e72, (%rbx)     # imm = 0x6F786E72
movabsq $0x6f2d59592d2e30, %rax # imm = 0x6F2D59592D2E30
movq %rax, 0x640d(%rbx)
movups 0x48cec(%rip), %xmm0    # 0x6b609
movups %xmm0, 0x6400(%rbx)
movb %r14b, 0x104(%rbx)
movl $0x6e786e72, 0x100(%rbx) # imm = 0x6E786E72
movups 0x48ce7(%rip), %xmm0    # 0x6b623
movups %xmm0, 0x6500(%rbx)
movl $0x6e2d59, 0x650f(%rbx) # imm = 0x6E2D59
movb %r14b, 0x204(%rbx)
movl $0x67786e72, 0x200(%rbx) # imm = 0x67786E72
movups 0x48cd6(%rip), %xmm0    # 0x6b63b
movups %xmm0, 0x6600(%rbx)
movl $0x672d59, 0x660f(%rbx) # imm = 0x672D59
movb %r14b, 0x304(%rbx)
movl $0x6c786e72, 0x300(%rbx) # imm = 0x6C786E72
movups 0x48cc5(%rip), %xmm0    # 0x6b653
movups %xmm0, 0x6700(%rbx)
movl $0x6c2d59, 0x670f(%rbx) # imm = 0x6C2D59
movb %r14b, 0x404(%rbx)
movl $0x62786e72, 0x400(%rbx) # imm = 0x62786E72
movups 0x48cb4(%rip), %xmm0    # 0x6b66b
movups %xmm0, 0x6800(%rbx)
movl $0x622d59, 0x680f(%rbx) # imm = 0x622D59
movb %r14b, 0x504(%rbx)
movl $0x63786e72, 0x500(%rbx) # imm = 0x63786E72
movups 0x48ca3(%rip), %xmm0    # 0x6b683
movups %xmm0, 0x6900(%rbx)
movl $0x632d59, 0x690f(%rbx) # imm = 0x632D59
movb %r14b, 0x604(%rbx)
movl $0x71786e72, 0x600(%rbx) # imm = 0x71786E72
movups 0x48c92(%rip), %xmm0    # 0x6b69b
movups %xmm0, 0x6a00(%rbx)
movl $0x712d59, 0x6a0f(%rbx) # imm = 0x712D59
movb %r14b, 0x704(%rbx)
movl $0x70786e72, 0x700(%rbx) # imm = 0x70786E72
movl $0x8, 0xc800(%rbx)
movups 0x48c77(%rip), %xmm0    # 0x6b6b3
movups %xmm0, 0x6b00(%rbx)
movl $0x702d59, 0x6b0f(%rbx) # imm = 0x702D59
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48ba1(%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 0x48b8c(%rip), %xmm0    # 0x6b623
movups %xmm0, 0x6500(%rdi)
movl $0x6e2d59, 0x650f(%rdi) # imm = 0x6E2D59
movb %al, 0x204(%rdi)
movl $0x67786e72, 0x200(%rdi) # imm = 0x67786E72
movups 0x48b7c(%rip), %xmm0    # 0x6b63b
movups %xmm0, 0x6600(%rdi)
movl $0x672d59, 0x660f(%rdi) # imm = 0x672D59
movb %al, 0x304(%rdi)
movl $0x6c786e72, 0x300(%rdi) # imm = 0x6C786E72
movups 0x48b6c(%rip), %xmm0    # 0x6b653
movups %xmm0, 0x6700(%rdi)
movl $0x6c2d59, 0x670f(%rdi) # imm = 0x6C2D59
movb %al, 0x404(%rdi)
movl $0x62786e72, 0x400(%rdi) # imm = 0x62786E72
movups 0x48b5c(%rip), %xmm0    # 0x6b66b
movups %xmm0, 0x6800(%rdi)
movl $0x622d59, 0x680f(%rdi) # imm = 0x622D59
movb %al, 0x504(%rdi)
movl $0x63786e72, 0x500(%rdi) # imm = 0x63786E72
movups 0x48b4c(%rip), %xmm0    # 0x6b683
movups %xmm0, 0x6900(%rdi)
movl $0x632d59, 0x690f(%rdi) # imm = 0x632D59
movb %al, 0x604(%rdi)
movl $0x71786e72, 0x600(%rdi) # imm = 0x71786E72
movups 0x48b3c(%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 0x48b22(%rip), %xmm0    # 0x6b6b3
movups %xmm0, 0x6b00(%rdi)
movl $0x702d59, 0x6b0f(%rdi) # imm = 0x702D59
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2aa68
leaq 0x69bc9(%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 0x263a5
movq -0x470(%rbp), %rax
movq -0x468(%rbp), %rsi
movq %rax, 0x6b76d(%rip)     # 0x91b48
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r14,%rdi), %rdx
addq %r15, %rdi
callq 0x27caa
movl $0x1c10, %edi           # imm = 0x1C10
leaq (%r14,%rdi), %rsi
addq %r15, %rdi
callq 0x27ef2
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 0x2aa1a
movb $0x1, 0x20(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x85b0
leaq 0x64(%rip), %rdx        # 0x26496
leaq -0x2060(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x8bb0
testl %eax, %eax
jne 0x26457
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x67b72(%rip), %rdi     # 0x8dfd0
leaq 0x455dc(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
jmp 0x2647e
movq %rax, %rbx
leaq -0x2060(%rbp), %rdi
callq 0x2aa1a
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2aa68
leaq 0x69a84(%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 0x264ea
movq -0x478(%rbp), %rax
movq -0x470(%rbp), %rsi
movq %rax, 0x6b628(%rip)     # 0x91b48
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r15,%rdi), %rdx
addq %r12, %rdi
callq 0x27caa
movl $0x1c10, %edi           # imm = 0x1C10
leaq (%r15,%rdi), %rsi
addq %r12, %rdi
callq 0x27ef2
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 0x2aa1a
movb $0x1, 0x20(%r14)
leaq 0x40(%r14), %rdi
callq 0x85b0
leaq -0xe2(%rip), %rdx       # 0x26496
leaq -0x2068(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x8bb0
testl %eax, %eax
jne 0x265b6
addq $0x28, %r14
cmpq %rbx, %r14
je 0x265a4
movq (%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x289e4
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x67a13(%rip), %rdi     # 0x8dfd0
leaq 0x4547d(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
jmp 0x265dd
movq %rax, %rbx
leaq -0x2068(%rbp), %rdi
callq 0x2aa1a
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29453
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 0x68ad0(%rip), %eax     # 0x91fa8
leal 0x1(%rax), %ecx
movl %ecx, 0x68ac7(%rip)     # 0x91fa8
testl %eax, %eax
jne 0x294f3
leaq 0x68ac4(%rip), %rdi     # 0x91fb0
xorl %esi, %esi
callq 0x8910
leaq 0x1c10(%rbx), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x2956f
leaq 0x1c40(%rbx), %rax
movq %rax, -0x48(%rbp)
xorl %r13d, %r13d
movslq %r13d, %r12
movq (%r15,%r12,8), %r14
cmpb $0x2d, (%r14)
jne 0x2952d
cmpb $0x68, 0x1(%r14)
jne 0x2952d
cmpb $0x0, 0x2(%r14)
je 0x2958b
movq %r14, %rdi
leaq 0x4254d(%rip), %rsi     # 0x6ba84
callq 0x8880
testl %eax, %eax
je 0x2958b
movq %r14, %rdi
leaq 0x42568(%rip), %rsi     # 0x6bab2
callq 0x8880
testl %eax, %eax
jne 0x29566
leal 0x1(%r12), %r13d
movq 0x8(%r15,%r12,8), %rsi
movq -0x48(%rbp), %rdi
callq 0x85c0
incl %r13d
cmpl -0x2c(%rbp), %r13d
jl 0x29512
movq %rbx, %rdi
movl $0x1, %esi
callq 0x295de
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x64a3e(%rip), %rdi     # 0x8dfd0
leaq 0x424f1(%rip), %rsi     # 0x6ba8a
movl $0x27, %edx
callq 0x8720
movq 0x64a26(%rip), %rdi     # 0x8dfd0
callq 0x8300
movl $0x1, %edi
callq 0x87b0
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2ae26
movq -0x40(%rbp), %rdi
callq 0x27eac
movq %rbx, %rdi
callq 0x8e3f
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a97b
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 0x675ac(%rip), %eax     # 0x91fa8
leal 0x1(%rax), %ecx
movl %ecx, 0x675a3(%rip)     # 0x91fa8
testl %eax, %eax
je 0x2aa0b
popq %rbp
retq
leaq 0x6759e(%rip), %rdi     # 0x91fb0
xorl %esi, %esi
popq %rbp
jmp 0x8910
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67534(%rip), %rdi     # 0x91fb0
callq 0x8900
movq %rbx, %rdi
callq 0x2a972
movq 0x67510(%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 0x2aaa6
movq 0x1bf0(%r14), %rax
movq %rax, 0x1bf0(%rbx)
cmpq %rbx, %r14
je 0x2aaeb
movl $0x1bf8, %edi           # imm = 0x1BF8
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x1bf8(%r14), %rsi
callq 0x27caa
movl $0x1c10, %esi           # imm = 0x1C10
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x27ef2
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 0x67492(%rip), %rdi     # 0x91fb0
callq 0x84b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ab33
movq %rax, %r14
movq %rbx, %rdi
callq 0x2aa1a
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67442(%rip), %rdi     # 0x91fa0
leaq -0x98(%rbp), %rsi
callq 0x8580
movq 0x6742f(%rip), %rsi     # 0x91fa0
testl %eax, %eax
je 0x2ab8e
addq $0x1c40, %rsi           # imm = 0x1C40
leaq 0x40f35(%rip), %rdi     # 0x6bab8
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8080
jmp 0x2abc6
movq 0x1bf0(%rsi), %rax
cmpq -0x40(%rbp), %rax
jne 0x2ab9f
xorl %ebx, %ebx
jmp 0x2abc6
leaq 0x6740a(%rip), %rbx     # 0x91fb0
movq %rbx, %rdi
callq 0x8900
movq 0x673eb(%rip), %rdi     # 0x91fa0
xorl %esi, %esi
callq 0x295de
movq %rbx, %rdi
callq 0x84b0
movb $0x1, %bl
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ac14
movq -0x38(%rbp), %rax
movq (%rax), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x8be0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x2abfe
movq -0x30(%rbp), %rax
leaq 0x1bf8(%rax), %r15
leaq -0x48(%rbp), %rbx
movq %r15, %r14
movq (%r14), %r14
cmpq %r15, %r14
je 0x2acad
movq %rbx, -0x58(%rbp)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x111e0
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %r13
testq %r13, %r13
je 0x2ac73
xorl %ebx, %ebx
movsbl (%r12,%rbx), %edi
callq 0x8be0
movb %al, (%r12,%rbx)
incq %rbx
cmpq %rbx, %r13
jne 0x2ac55
movq -0x58(%rbp), %r12
leaq -0x48(%rbp), %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x4, %edx
movq %r12, %rsi
callq 0x82f0
movl %eax, %r13d
cmpq %rbx, %r12
je 0x2ac97
movq %r12, %rdi
callq 0x85d0
testl %r13d, %r13d
jne 0x2ac26
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 0x2ac9e
movq %rdx, -0x60(%rbp)
leaq 0x40(%rdx), %r13
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x2ad53
movq %rbx, -0x58(%rbp)
movq 0x30(%r12), %rsi
movq 0x38(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x111e0
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %r14
testq %r14, %r14
je 0x2ad25
xorl %ebx, %ebx
movsbl (%r15,%rbx), %edi
callq 0x8be0
movb %al, (%r15,%rbx)
incq %rbx
cmpq %rbx, %r14
jne 0x2ad07
movq -0x58(%rbp), %r15
leaq -0x48(%rbp), %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x82f0
movl %eax, %r14d
cmpq %rbx, %r15
je 0x2ad49
movq %r15, %rdi
callq 0x85d0
testl %r14d, %r14d
jne 0x2acd5
jmp 0x2ac9c
movq -0x60(%rbp), %rdi
callq 0x8460
movq %rax, %rdx
cmpq -0x30(%rbp), %rax
jne 0x2acca
movb $0x1, %al
jmp 0x2ac9e
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rdi, %r15
leaq 0xa0f40(%rdi), %r14
movq %r14, %rdi
callq 0x8900
leaq 0xa0ec8(%r15), %rdi
movq 0xa0ec8(%r15), %r12
movq %rdi, %rbx
cmpq %rdi, %r12
je 0x2b60b
movq 0x8(%r13), %rax
xorl %ebx, %ebx
cmpq 0x18(%r12), %rax
jl 0x2b62a
movq 0xa0ed0(%r15), %rcx
movq %rdi, %rbx
cmpq 0x18(%rcx), %rax
jg 0x2b60b
cmpq 0x18(%r12), %rax
jle 0x2b599
movq (%r12), %r12
cmpq %rdi, %r12
jne 0x2b589
cmpq %rax, 0x18(%r12)
jne 0x2b608
movq 0x30(%r13), %r15
addq $0x20, %r13
movl $0x1, %ebx
cmpq %r13, %r15
je 0x2b62a
movq %r13, -0x38(%rbp)
movq %r14, -0x30(%rbp)
leaq 0x28(%r12), %r13
addq $0x30, %r12
leaq 0x20(%r15), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2d212
cmpq %r12, %rax
jne 0x2b5f1
leaq 0x40(%r15), %r14
movq %r13, %rdi
movq %rbx, %rsi
callq 0x27c14
movq %rax, %rdi
movq %r14, %rsi
callq 0x28548
movq %r15, %rdi
callq 0x8460
movq %rax, %r15
cmpq -0x38(%rbp), %rax
jne 0x2b5c3
movq -0x30(%rbp), %r14
jmp 0x2b625
movq %r12, %rbx
movq %r13, %rsi
callq 0x2cd98
movq %rax, %rdi
movq %rbx, %rsi
callq 0x80c0
incq 0xa0ed8(%r15)
movl $0x1, %ebx
movq %r14, %rdi
callq 0x84b0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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        # 0x2b690
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8bb0
testl %eax, %eax
jne 0x2b66b
addq $0x10, %rsp
popq %rbp
retq
movq 0x6295e(%rip), %rdi     # 0x8dfd0
leaq 0x403c8(%rip), %rsi     # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40291(%rip), %rsi     # 0x6bc88
leaq -0x160(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8120
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x57d6e
movq %r14, %rdi
movl $0x3, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x57dbf
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 0x8900
movq -0x40(%rbp), %rax
movq 0xa0ef8(%rax), %rax
cmpq -0x50(%rbp), %rax
je 0x2babf
leaq 0x40(%rax), %r15
movq %rax, -0x38(%rbp)
movq 0x40(%rax), %rbx
cmpq %r15, %rbx
je 0x2bab4
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x10(%rbx), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2c3b4
movl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x59f9f
movq (%rbx), %rbx
jmp 0x2ba7e
movq -0x38(%rbp), %rdi
callq 0x8460
jmp 0x2ba6c
movq -0x40(%rbp), %rax
movq 0xa0f28(%rax), %rax
cmpq -0x48(%rbp), %rax
je 0x2bb1d
leaq 0x40(%rax), %r15
movq %rax, -0x38(%rbp)
movq 0x40(%rax), %rbx
cmpq %r15, %rbx
je 0x2bb12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x10(%rbx), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2c646
movl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x59f9f
movq (%rbx), %rbx
jmp 0x2badc
movq -0x38(%rbp), %rdi
callq 0x8460
jmp 0x2baca
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x84b0
movl $0x1388, %edi           # imm = 0x1388
callq 0x4ff28
jmp 0x2ba59
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f2b1
movl (%r15), %edx
leaq 0x40159(%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_O3/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 0x1cc5e
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 0x3f607(%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 0x3f602(%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_O3/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 0x3e175(%rip), %rsi     # 0x6c028
xorl %r14d, %r14d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4d55d
movslq 0x81a74(%rbx), %rax
testq %rax, %rax
je 0x2df2e
leal 0x1(%rax), %ecx
movl %ecx, 0x81a74(%rbx)
movb %r15b, 0x81a90(%rbx,%rax)
movl 0x81a74(%rbx), %eax
cmpl $0x4, %eax
jl 0x2dfa8
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 0x2df4e
incq %rdx
cmpq $0x81a95, %rdx          # imm = 0x81A95
jne 0x2def8
shll $0x8, %ecx
movzbl 0x81a95(%rbx), %esi
orl %ecx, %esi
movl $0x4, %edx
movl %esi, %ecx
jmp 0x2df54
leaq 0x81a90(%rbx), %rdi
movzbl %r15b, %esi
callq 0x2dfcf
testl %eax, %eax
je 0x2dfa8
movl $0x2, 0x81a74(%rbx)
jmp 0x2dfa8
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 0x2df91
leaq 0x3e0cb(%rip), %rsi     # 0x6c03e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x2dfa8
xorl %ecx, %ecx
cmpl $0x80, %edx
setl %cl
subl %ecx, %esi
addl $0x2, %esi
xorl %r14d, %r14d
cmpl %esi, %eax
jge 0x2dfb6
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 0x2e005
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e003
movl $0x1, %eax
cmpb $0x4, %sil
jb 0x2e003
movzbl %sil, %ecx
addl $-0x7d, %ecx
cmpl $0x2, %ecx
jb 0x2e003
xorl %eax, %eax
cmpb $0x7f, %sil
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39c27(%rip), %rsi     # 0x6c05a
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
cmpl $0x0, 0x81a74(%rbx)
je 0x324ad
leaq 0x81a92(%rbx), %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x8920
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x4, %rax
jb 0x325a5
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 0x324ff
incq %rax
cmpq $0x81a95, %rax          # imm = 0x81A95
jne 0x32478
shll $0x8, %ecx
movzbl 0x81a95(%rbx), %edx
orl %ecx, %edx
movl $0x4, %eax
movl %edx, %ecx
jmp 0x32504
movq %r14, %rdi
callq 0x89c0
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x1, %eax
je 0x325a5
leaq 0x81a90(%rbx), %r12
movl $0x1001, %r13d          # imm = 0x1001
movzbl %al, %esi
movq %r12, %rdi
callq 0x2dfcf
testl %eax, %eax
jne 0x32448
decl %r13d
je 0x325a2
movq %r14, %rdi
callq 0x89c0
cmpl $-0x1, %eax
jne 0x324d1
jmp 0x325a5
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 0x32542
leaq 0x39b1a(%rip), %rsi     # 0x6c03e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x325a5
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 0x8920
movl 0x81a78(%rbx), %ecx
addl %r12d, %ecx
addl $-0x5, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jb 0x325a5
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e005
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_O3/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 0x4f2b1
movsd 0x397fb(%rip), %xmm1    # 0x6bdd0
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
jbe 0x325f2
addsd 0x397f8(%rip), %xmm1    # 0x6bde8
jmp 0x32608
addsd 0x397de(%rip), %xmm0    # 0x6bdd8
ucomisd %xmm0, %xmm1
jbe 0x32608
addsd 0x397d8(%rip), %xmm1    # 0x6bde0
movl -0x4(%rbp), %edi
movapd %xmm1, %xmm0
callq 0x4f24a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, -0x10(%rbp)
leaq -0x40(%rbp), %rbx
movq %rbx, %rsi
callq 0x4f104
movsd 0x18(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
mulsd 0x38272(%rip), %xmm1    # 0x6a8b8
mulsd 0x38272(%rip), %xmm0    # 0x6a8c0
addsd %xmm1, %xmm0
addsd 0x28(%rbx), %xmm0
movsd 0x39791(%rip), %xmm1    # 0x6bdf0
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
jbe 0x3267c
addsd 0x38256(%rip), %xmm1    # 0x6a8d0
jmp 0x32692
addsd 0x39774(%rip), %xmm0    # 0x6bdf8
ucomisd %xmm0, %xmm1
jbe 0x32697
addsd 0x3976e(%rip), %xmm1    # 0x6be00
movsd %xmm1, -0x10(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x4f027
movq %rax, %rdi
movsd -0x10(%rbp), %xmm1
callq 0x4f4e7
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x395a7(%rip), %xmm1    # 0x6bc78
ucomisd %xmm0, %xmm1
jbe 0x326e5
divsd 0x390e1(%rip), %xmm0    # 0x6b7c0
cvttsd2si %xmm0, %eax
jmp 0x3275d
movsd 0x37233(%rip), %xmm1    # 0x69920
ucomisd %xmm0, %xmm1
jbe 0x3270c
addsd 0x382f5(%rip), %xmm0    # 0x6a9f0
divsd 0x3971d(%rip), %xmm0    # 0x6be20
cvttsd2si %xmm0, %eax
addl $0x32, %eax
jmp 0x3275d
movsd 0x3969c(%rip), %xmm1    # 0x6bdb0
ucomisd %xmm0, %xmm1
jbe 0x32733
addsd 0x3828e(%rip), %xmm0    # 0x6a9b0
divsd 0x396ee(%rip), %xmm0    # 0x6be18
cvttsd2si %xmm0, %eax
addl $0x4b, %eax
jmp 0x3275d
movl $0xff, %eax
movsd 0x382f8(%rip), %xmm1    # 0x6aa38
ucomisd %xmm0, %xmm1
jb 0x3275d
addsd 0x396ba(%rip), %xmm0    # 0x6be08
divsd 0x396ba(%rip), %xmm0    # 0x6be10
cvttsd2si %xmm0, %eax
addl $0x64, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
testl %edi, %edi
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x328c3
movl %esi, %r14d
movl %edi, %r15d
movq %rdx, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movq %r8, -0x48(%rbp)
movl %edi, %esi
callq 0x4ddc1
movq %rax, %rbx
movl %r15d, %edi
movl $0x1, %esi
callq 0x4dc73
movq %rax, %r13
movl %r15d, %edi
callq 0x4de09
movq %rax, -0x30(%rbp)
movl %r15d, %edi
movl $0x1, %esi
callq 0x4dc73
movq %rax, -0x38(%rbp)
movl %r15d, %edi
movl %r14d, %esi
callq 0x4dc73
movq %rax, -0x40(%rbp)
movl %r15d, %edi
movq %r12, %rsi
movq %rbx, %r12
movq %rbx, %rdx
movq %r13, %rcx
callq 0x328d4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
movq %r13, -0x60(%rbp)
je 0x3280d
movq -0x40(%rbp), %r13
jmp 0x32898
movl %r15d, %edi
movq %r12, %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
callq 0x32a85
movq -0x38(%rbp), %rax
movq %rax, (%rsp)
leaq 0x3a432(%rip), %rdi     # 0x6cc60
movsd 0x370ea(%rip), %xmm0    # 0x69920
xorps %xmm1, %xmm1
movl %r15d, %esi
movl $0x1, %edx
movl %r15d, %ecx
movq -0x30(%rbp), %r8
movq -0x50(%rbp), %r9
callq 0x4dfb0
movq -0x58(%rbp), %rax
movq %rax, (%rsp)
movl %r15d, %edi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r13
movq %r13, %r9
callq 0x32d70
testl %eax, %eax
jne 0x32898
leaq 0x461e4(%rip), %rdi     # 0x78a64
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movl %r15d, %ecx
movl %r14d, %r8d
movq -0x48(%rbp), %r9
callq 0x4e5f7
movl %eax, %ebx
movq %r12, %rdi
callq 0x87a0
movq -0x60(%rbp), %rdi
callq 0x87a0
movq -0x30(%rbp), %rdi
callq 0x87a0
movq -0x38(%rbp), %rdi
callq 0x87a0
movq %r13, %rdi
callq 0x87a0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::LD(int, double const*, double*, double*)
static int LD(int n, const double *Q, double *L, double *D)
{
    int i,j,k,info=0;
    double a,*A=mat(n,n);
    
    memcpy(A,Q,sizeof(double)*n*n);
    for (i=n-1;i>=0;i--) {
        if ((D[i]=A[i+i*n])<=0.0) {info=-1; break;}
        a=sqrt(D[i]);
        for (j=0;j<=i;j++) L[i+j*n]=A[i+j*n]/a;
        for (j=0;j<=i-1;j++) for (k=0;k<=j;k++) A[j+k*n]-=L[i+k*n]*L[i+j*n];
        for (j=0;j<=i;j++) L[i+j*n]/=L[i+i*n];
    }
    free(A);
    if (info) fprintf(stderr,"%s : LD factorization error\n",__FILE__);
    return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x60(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebx
movl %edi, %esi
callq 0x4dc73
movq %rax, %r15
movl %ebx, %edx
movq %rdx, -0x48(%rbp)
imulq %rdx, %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x84f0
movq %r15, %rdi
movq %rbx, %r10
testl %r10d, %r10d
jle 0x32a63
leal 0x1(%r10), %eax
movl %eax, -0x2c(%rbp)
decl %r10d
movq -0x48(%rbp), %rax
leaq (,%rax,8), %rbx
leaq (%rdi,%rax,8), %r12
addq $-0x8, %r12
leaq (%r14,%rax,8), %r13
addq $-0x8, %r13
xorpd %xmm2, %xmm2
movq %rax, %rdx
movq %rdi, -0x50(%rbp)
leaq -0x1(%rdx), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %r15d
imull %esi, %r15d
movsd (%rdi,%r15,8), %xmm0
movq -0x60(%rbp), %rax
movsd %xmm0, -0x8(%rax,%rdx,8)
ucomisd %xmm0, %xmm2
jae 0x32a79
ucomisd %xmm2, %xmm0
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
jb 0x32990
sqrtsd %xmm0, %xmm0
jmp 0x329ad
movq %r10, -0x58(%rbp)
callq 0x84e0
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorpd %xmm2, %xmm2
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %r10
movq %rdx, %rax
xorl %ecx, %ecx
movsd (%r12,%rcx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r13,%rcx)
addq %rbx, %rcx
decq %rax
jne 0x329b2
movq %rdx, %rax
movq %r13, %rcx
cmpq $0x2, %rdx
jl 0x32a35
leaq (%r14,%rsi,8), %rax
movl $0x1, %ecx
movq %rdi, %rdx
xorl %esi, %esi
movq %rsi, %r11
imulq -0x48(%rbp), %r11
movq %rcx, %r8
xorl %r9d, %r9d
movsd (%r13,%r9), %xmm0
movsd (%rdx,%r9), %xmm1
mulsd (%rax,%r11,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r9)
addq %rbx, %r9
decq %r8
jne 0x329f3
incq %rsi
incq %rcx
addq $0x8, %rdx
cmpq %r10, %rsi
jne 0x329e5
movq -0x40(%rbp), %rdx
movq %rdx, %rax
movq %r13, %rcx
movq -0x38(%rbp), %rsi
movsd (%rcx), %xmm0
divsd (%r14,%r15,8), %xmm0
movsd %xmm0, (%rcx)
addq %rbx, %rcx
decq %rax
jne 0x32a35
decq %r10
addq $-0x8, %r12
addq $-0x8, %r13
cmpq $0x1, %rdx
movq %rsi, %rdx
jg 0x32954
callq 0x87a0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8e74
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x32a6a