LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Logging.hpp
// Function: Logging::logInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Logging::logInfo(const string &msg) {
	if (logging_mask < 3) {
		pthread_mutex_lock(&mutex_logging);
		cout << "[" << currentDateTime() << "][INFO]: " << msg << endl;
		pthread_mutex_unlock(&mutex_logging);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x2, 0xdc90(%rip)      # 0x13388
jg 0x57b9
movq %rdi, %rbx
leaq 0xdcc0(%rip), %rdi      # 0x133c8
callq 0x34f0
movq 0xd8c4(%rip), %r14      # 0x12fd8
leaq 0x8b6f(%rip), %rsi      # 0xe28a
movl $0x1, %edx
movq %r14, %rdi
callq 0x3400
movq %rsp, %r15
movq %r15, %rdi
callq 0x425f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %r14
leaq 0x894d(%rip), %rsi      # 0xe099
movl $0x9, %edx
movq %rax, %rdi
callq 0x3400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0xdc14(%rip), %rdi      # 0x133c8
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Logging.hpp
// Function: Logging::logWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Logging::logWarning(const string &msg) {
	if (logging_mask < 4) {
		pthread_mutex_lock(&mutex_logging);
		cout << "[" << currentDateTime() << "][WARNING]: " << msg << endl;
		pthread_mutex_unlock(&mutex_logging);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x3, 0xdb8e(%rip)      # 0x13388
jg 0x58bb
movq %rdi, %rbx
leaq 0xdbbe(%rip), %rdi      # 0x133c8
callq 0x34f0
movq 0xd7c2(%rip), %r14      # 0x12fd8
leaq 0x8a6d(%rip), %rsi      # 0xe28a
movl $0x1, %edx
movq %r14, %rdi
callq 0x3400
movq %rsp, %r15
movq %r15, %rdi
callq 0x425f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %r14
leaq 0x8855(%rip), %rsi      # 0xe0a3
movl $0xc, %edx
movq %rax, %rdi
callq 0x3400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0xdb12(%rip), %rdi      # 0x133c8
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58e3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Logging.hpp
// Function: Logging::logError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Logging::logError(const string &msg) {
	if (logging_mask < 5) {
		pthread_mutex_lock(&mutex_logging);
		cout << "[" << currentDateTime() << "][ERROR]: " << msg << endl;
		pthread_mutex_unlock(&mutex_logging);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x4, 0xda8c(%rip)      # 0x13388
jg 0x59bd
movq %rdi, %rbx
leaq 0xdabc(%rip), %rdi      # 0x133c8
callq 0x34f0
movq 0xd6c0(%rip), %r14      # 0x12fd8
leaq 0x896b(%rip), %rsi      # 0xe28a
movl $0x1, %edx
movq %r14, %rdi
callq 0x3400
movq %rsp, %r15
movq %r15, %rdi
callq 0x425f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %r14
leaq 0x8760(%rip), %rsi      # 0xe0b0
movl $0xa, %edx
movq %rax, %rdi
callq 0x3400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3400
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0xda10(%rip), %rdi      # 0x133c8
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: Messaging::clearFileCache()
void Messaging::clearFileCache() {
	// file content
	map<string, string* >::iterator it1;
	for(it1=file_cache_bytes.begin(); it1!=file_cache_bytes.end(); ++it1) {
		delete it1->second;
	}
	file_cache_bytes.clear();

	map<string, vector<string>* >::iterator it2;
	for(it2=file_cache_lines.begin(); it2!=file_cache_lines.end(); ++it2) {
		delete it2->second;
	}
	file_cache_lines.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x70(%rdi), %r15
leaq 0x60(%rdi), %r13
cmpq %r13, %r15
je 0x5b28
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x5b0b
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rax, %rdi
je 0x5b0b
movq (%rax), %rsi
incq %rsi
callq 0x3390
movl $0x20, %esi
movq %r12, %rdi
callq 0x3390
movq %r15, %rdi
callq 0x3230
movq %rax, %r15
cmpq %r13, %rax
jne 0x5ae9
movq %r14, %rdi
callq 0xccb6
movq 0xa0(%rbx), %r14
leaq 0x90(%rbx), %r12
cmpq %r12, %r14
je 0x5b71
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x5b54
movq %r15, %rdi
callq 0xbc26
movl $0x18, %esi
movq %r15, %rdi
callq 0x3390
movq %r14, %rdi
callq 0x3230
movq %rax, %r14
cmpq %r12, %rax
jne 0x5b43
addq $0x88, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcce4
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: Messaging::clearShuffleCache()
void Messaging::clearShuffleCache() {
	// fetch content
	map< long, vector< vector<string>* > >::iterator it3;
	for(it3=fetch_content_local.begin(); it3!=fetch_content_local.end(); ++it3) {
		for (unsigned int i=0; i<it3->second.size(); i++) {
			delete it3->second[i];
		}
		it3->second.clear();
	}
	fetch_content_local.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xd0(%rdi), %r14
leaq 0xc0(%rdi), %r12
cmpq %r12, %r14
je 0x5c0e
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
cmpq %rax, %rcx
je 0x5bf5
movl $0x1, %ebp
xorl %edx, %edx
movq (%rax,%rdx,8), %r15
testq %r15, %r15
je 0x5bcd
movq %r15, %rdi
callq 0xbc26
movl $0x18, %esi
movq %r15, %rdi
callq 0x3390
movl %ebp, %edx
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x5bbc
cmpq %rax, %rcx
je 0x5bfe
movq %rax, 0x30(%r14)
movq %r14, %rdi
callq 0x3230
movq %rax, %r14
cmpq %r12, %rax
jne 0x5ba8
addq $0xb8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xcd12
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: readSocket(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readSocket(int socketfd, string &ret) {
	//int MAX_MESSAGE_SIZE = 1024 * 1024 * 1024; // TODO configuration out of code
	int BUFFER_SIZE = 1024 * 1024 * 4; // TODO configuration out of code

	char buffer[BUFFER_SIZE];
	ssize_t total = 0;
	vector<string> strs;
	while (true) { // && total < MAX_MESSAGE_SIZE
		memset(buffer, 0, BUFFER_SIZE);
		ssize_t received = recv(socketfd, buffer, BUFFER_SIZE - 1, 0);

		if(received <= 0) break;

		total += received;
		strs.push_back(buffer);
	}

	ret = "";
	for(unsigned int i = 0; i < strs.size(); i++) {
		ret += strs[i];
	}

//	string::size_type end = ret.find(END_OF_MESSAGE);
//	if (end != string::npos) {
//		total = end;
//		ret = ret.substr(0, end);
//	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400048, %rsp         # imm = 0x400048
movq %rsi, %rbx
movl %edi, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x30(%rsp), %r13
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
movl $0x400000, %edx         # imm = 0x400000
movq %r15, %rdi
xorl %esi, %esi
callq 0x31f0
movl $0x3fffff, %edx         # imm = 0x3FFFFF
movl %ebp, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x3140
testq %rax, %rax
jle 0x5cc5
movq %r13, 0x20(%rsp)
movq %r15, %rdi
callq 0x3180
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xc5ec
movq %r14, %rdi
movq %r12, %rsi
callq 0xcaa6
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c5c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0x5c5c
movq 0x8(%rbx), %rdx
leaq 0x83fb(%rip), %rcx      # 0xe0cb
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3560
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x5d1d
movl $0x1, %ebp
xorl %ecx, %ecx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x3120
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5cef
movq %rsp, %rdi
callq 0xbc26
addq $0x400048, %rsp         # imm = 0x400048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d59
jmp 0x5d59
jmp 0x5d59
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x5d5c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0x5d5c
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbc26
movq %rbx, %rdi
callq 0x3640
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: sendEndOfMessage(int)
bool sendEndOfMessage(int socket_fd) {
	const char* ch = END_OF_MESSAGE;
	int rsend = send(socket_fd, ch, strlen(ch), 0);
	if (rsend < 0)
	{
		Logging::logError("Messaging: sendEndOfMessage: send END_OF_MESSAGE, failed to send");
		return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x833f(%rip), %rsi      # 0xe0bb
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x31c0
movq %rax, %rbx
testl %ebx, %ebx
jns 0x5dcf
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x832d(%rip), %rsi      # 0xe0cc
leaq 0x8366(%rip), %rdx      # 0xe10c
movq %rsp, %r14
movq %r14, %rdi
callq 0xc5ec
movq %r14, %rdi
callq 0x58ec
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5dcf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
testl %ebx, %ebx
setns %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5df7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: Messaging::sendMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Messaging::sendMessage(string addr, int targetPort, int msgType, string &msg)
{
	string reply;
	if(!sendMessageForReply(addr, targetPort, msgType, msg, reply)) {
		Logging::logError("Messaging: sendMessage: failed to send");
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xc556
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %r9
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x606e
movl %eax, %ebx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x634a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3390
testb %bl, %bl
jne 0x638b
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x7ee8(%rip), %rsi      # 0xe246
leaq 0x7f07(%rip), %rdx      # 0xe26c
movq %rsp, %rdi
callq 0xc5ec
movq %rsp, %rdi
callq 0x58ec
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x638b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x63a2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3390
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x63e5
movq 0x10(%rsp), %rsi
jmp 0x63d8
jmp 0x63e2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x63e5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0x63e5
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x63fc
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/include/Messaging.hpp
// Function: send(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void send(int socket_fd, string &msg) {
	int rsend = 0;
	if(msg == "") {
		string empty_msg = EMPTY_MESSAGE;
		rsend = send(socket_fd, empty_msg.c_str(), empty_msg.length(), 0);
	}
	else {
		rsend = send(socket_fd, msg.c_str(), msg.length(), 0);
	}
	if (rsend < 0) {
		// send failed
		Logging::logError("Messaging::messageHandler: reply FILE_BLOCK_REQUEST, failed to send");
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6779(%rip), %rsi      # 0xe0cb
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x7973
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x31c0
movq %rax, %rbx
jmp 0x79c1
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x686a(%rip), %rsi      # 0xe1ed
leaq 0x6872(%rip), %rdx      # 0xe1fc
leaq 0x8(%rsp), %rdi
callq 0xc5ec
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x31c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x79c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
testl %ebx, %ebx
jns 0x7a07
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x691f(%rip), %rsi      # 0xe2f4
leaq 0x695b(%rip), %rdx      # 0xe337
leaq 0x8(%rsp), %rdi
callq 0xc5ec
leaq 0x8(%rsp), %rdi
callq 0x58ec
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x7a13
jmp 0x7a2f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a32
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0x7a32
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3640
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: startHelperListening(void*)
void *startHelperListening(void *data) {
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	struct thread_data *my_data;
	my_data = (struct thread_data *)data;
	my_data->helper.listenMessage(my_data->v);

	pthread_exit(NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x3520
movq (%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x6404
xorl %edi, %edi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: sendHostResourceInfoToMasterRepeatedly(void*)
void *sendHostResourceInfoToMasterRepeatedly(void *data) {
	xyz_send_host_resource_info_thread_canceled_flag = false;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	struct thread_data *my_data;
	my_data = (struct thread_data *)data;

	while(true) {
		if (xyz_send_host_resource_info_thread_cancel_flag) {
			xyz_send_host_resource_info_thread_cancel_flag = false;
			xyz_send_host_resource_info_thread_canceled_flag = true;
			break;
		}
		sleep(1);
		my_data->helper.sendHostResourceInfoToMaster(string(my_data->msg));
		sleep(5);
	}

	pthread_exit(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movb $0x0, 0xb938(%rip)      # 0x133a8
xorl %edi, %edi
xorl %esi, %esi
callq 0x3520
cmpb $0x0, 0xb9f8(%rip)      # 0x13478
jne 0x7ae2
leaq 0x20(%rsp), %r13
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %r15
movl $0x1, %edi
callq 0x3280
movq (%rbx), %r12
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xbe80
movq %r12, %rdi
movq %r14, %rsi
callq 0x7b1a
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7acf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3390
movl $0x5, %edi
callq 0x3280
cmpb $0x0, 0xb998(%rip)      # 0x13478
je 0x7a91
movb $0x0, 0xb98f(%rip)      # 0x13478
movb $0x1, 0xb8b8(%rip)      # 0x133a8
xorl %edi, %edi
callq 0x3650
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7b11
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::sendHostResourceInfoToMaster(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SunwayMRHelper::sendHostResourceInfoToMaster(string msg) {
	stringstream ss;
	ss << "SunwayMRHelper: send resource info to master: " << masterAddr << ":"
			<< masterListenPort << ", message: " << msg;
	Logging::logVerbose(ss.str());
	Messaging::sendMessage(masterAddr, masterListenPort, HOST_RESOURCE_INFO, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rsp), %rdi
callq 0x3240
leaq 0x58(%rsp), %r15
leaq 0x69d6(%rip), %rsi      # 0xe518
movl $0x2e, %edx
movq %r15, %rdi
callq 0x3400
movq 0xf0(%r14), %rsi
movq 0xf8(%r14), %rdx
movq %r15, %rdi
callq 0x3400
movq %rax, %r15
leaq 0x6a57(%rip), %rsi      # 0xe5c6
movl $0x1, %edx
movq %rax, %rdi
callq 0x3400
movl 0x130(%r14), %esi
movq %r15, %rdi
callq 0x3600
movq %rax, %r15
leaq 0x69b2(%rip), %rsi      # 0xe547
movl $0xb, %edx
movq %rax, %rdi
callq 0x3400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x3400
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3580
leaq 0x28(%rsp), %rdi
callq 0x54e4
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7be5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xf0(%r14), %rsi
movq 0xf8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xc556
movl 0x130(%r14), %edx
leaq 0x8(%rsp), %rsi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x62d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0xb373(%rip), %rsi      # 0x12fb0
leaq 0x48(%rsp), %rdi
callq 0x3260
leaq 0xc8(%rsp), %rdi
callq 0x3150
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c9a
movq 0x18(%rsp), %rsi
jmp 0x7c8b
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7c9a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0x7c9a
jmp 0x7c97
movq %rax, %rbx
movq 0xb30f(%rip), %rsi      # 0x12fb0
leaq 0x48(%rsp), %rdi
callq 0x3260
leaq 0xc8(%rsp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3640
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::init()
bool SunwayMRHelper::init() {
	bool ret = false;

	if (localAddr == masterAddr) {
		Logging::logInfo("SunwayMRHelper: master is self");
		listenPort = masterListenPort;
		ret = initListening(listenPort);

	} else {
		listenPort = randomValue(20001, 29999);
		ret = initListening(listenPort);

		int try_time = 0;
		while (!ret && try_time < 100) {
			try_time++;
			listenPort += 3;

			ret = initListening(listenPort);
		}
	}

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x118(%rdi), %rdx
cmpq 0xf8(%rdi), %rdx
jne 0x858e
testq %rdx, %rdx
je 0x85e6
movq 0xf0(%rbx), %rsi
movq 0x110(%rbx), %rdi
callq 0x33a0
testl %eax, %eax
je 0x85e6
movl $0x4e21, %edi           # imm = 0x4E21
movl $0x752f, %esi           # imm = 0x752F
callq 0x42ec
movl %eax, 0x13c(%rbx)
movq %rbx, %rdi
movl %eax, %esi
callq 0xa4ae
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x863a
xorl %r14d, %r14d
movl 0x13c(%rbx), %esi
addl $0x3, %esi
movl %esi, 0x13c(%rbx)
movq %rbx, %rdi
callq 0xa4ae
testb %al, %al
jne 0x863a
leal 0x1(%r14), %ecx
cmpl $0x63, %r14d
movl %ecx, %r14d
jb 0x85bc
jmp 0x863a
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6190(%rip), %rsi      # 0xe786
leaq 0x61a7(%rip), %rdx      # 0xe7a4
movq %rsp, %r14
movq %r14, %rdi
callq 0xc5ec
movq %r14, %rdi
callq 0x56e8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8626
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movl 0x130(%rbx), %esi
movl %esi, 0x13c(%rbx)
movq %rbx, %rdi
callq 0xa4ae
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x865d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::initListening(int)
bool SunwayMRHelper::initListening(int port) {
	string msg;
	int listenPort = port;
	struct thread_data *data = new thread_data (*this, "", listenPort);
	pthread_t thread;
	pthread_mutex_init(&mutex_listen_status, NULL);
	pthread_mutex_lock(&mutex_listen_status);
	int rc = pthread_create(&thread, NULL, startHelperListening, (void *)data);
	if (rc){
		Logging::logError("JobScheduler: failed to create thread to listen");
	}

	pthread_mutex_lock(&mutex_listen_status);
	pthread_mutex_unlock(&mutex_listen_status);

	if(getListenStatus() == SUCCESS) {
		setLocalResouce(this->threads, this->memory);
		void *status;
		pthread_join(thread, &status); // always listen

		Logging::logInfo("SunwayMRHelper: listen thread finished");

		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movl $0x18, %edi
callq 0x3380
movq %rax, %r15
movq %rbx, (%rax)
leaq 0x3bdd(%rip), %rax      # 0xe0cb
movq %rax, 0x8(%r15)
movl %ebp, 0x10(%r15)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3510
movq %r14, %rdi
callq 0x34f0
leaq -0x2ad9(%rip), %rdx     # 0x7a3a
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x3670
testl %eax, %eax
je 0xa563
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x41f9(%rip), %rsi      # 0xe72f
leaq 0x4221(%rip), %rdx      # 0xe75e
movq %rsp, %rdi
callq 0xc5ec
movq %rsp, %rdi
callq 0x58ec
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa563
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq %r14, %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3290
movl 0xe8(%rbx), %ebp
cmpl $0x1, %ebp
jne 0xa5de
movl 0x134(%rbx), %esi
movl 0x138(%rbx), %edx
movq %rbx, %rdi
callq 0x86ea
movq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3320
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x41ae(%rip), %rsi      # 0xe75f
leaq 0x41cd(%rip), %rdx      # 0xe785
movq %rsp, %rdi
callq 0xc5ec
movq %rsp, %rdi
callq 0x56e8
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xa5de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa5f5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
cmpl $0x1, %ebp
sete %al
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0xa628
jmp 0xa63a
jmp 0xa637
jmp 0xa637
jmp 0xa637
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa63a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
jmp 0xa63a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa651
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O3/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::update(HostResource)
void SunwayMRHelper::update(HostResource hr) {
	bool updated = false;
	for (unsigned int i=0; i<allResources.size(); i++) {
		if(allResources[i].host == hr.host) {
			allResources[i].threads = hr.threads;
			allResources[i].memory = hr.memory;
			allResources[i].listenPort = hr.listenPort;
			updated = true;
			break;
		}
	}
	if(!updated) {
		allResources.push_back(hr);
	}

	saveLocalHostFile();
	saveAllHostsFile();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x140(%rdi), %r12
movq %rdi, (%rsp)
movq 0x148(%rdi), %rax
subq %r12, %rax
je 0xb0ca
sarq $0x4, %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
movq 0x8(%r14), %r15
movl $0x1, %ebp
xorl %eax, %eax
leaq (%rax,%rax,2), %rbx
shlq $0x4, %rbx
cmpq %r15, 0x8(%r12,%rbx)
jne 0xb0c1
addq %r12, %rbx
testq %r15, %r15
je 0xb0df
movq (%r14), %rsi
movq (%rbx), %rdi
movq %r15, %rdx
callq 0x33a0
testl %eax, %eax
je 0xb0df
movl %ebp, %eax
incl %ebp
cmpq %rax, %r13
ja 0xb098
movq (%rsp), %rbx
leaq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0xc1c2
jmp 0xb0f2
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0xb110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb41c
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: void run_exprtk_benchmark<double>(double&, double&, exprtk::expression<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_exprtk_benchmark(T& x, T& y,
                          exprtk::expression<T>& expression,
                          const std::string& expr_string)
{
   T total = T(0);
   unsigned int count = 0;

   exprtk::timer timer;
   timer.start();

   for (x = global_lower_bound_x; x <= global_upper_bound_x; x += global_delta)
   {
      for (y = global_lower_bound_y; y <= global_upper_bound_y; y += global_delta)
      {
         total += expression.value();
         ++count;
      }
   }

   timer.stop();

   if (T(0) != total)
      printf("[exprtk] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
             timer.time(),
             count / timer.time(),
             expr_string.c_str());
   else
      printf("run_exprtk_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
movb $0x1, -0x8(%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x118280
movabsq $-0x3fa7000000000000, %rbp # imm = 0xC059000000000000
movq %rbp, (%r12)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbp, (%r15)
movsd 0x8(%rsp), %xmm3
movsd %xmm3, 0x8(%rsp)
movq (%r14), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm3
movsd 0x19295a(%rip), %xmm2   # 0x2b2018
movsd 0x19294a(%rip), %xmm1   # 0x2b2010
addsd %xmm0, %xmm3
incl %r13d
movsd (%r15), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r15)
ucomisd %xmm0, %xmm2
jae 0x11f69d
movsd %xmm3, 0x8(%rsp)
movsd (%r12), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r12)
ucomisd %xmm0, %xmm2
jae 0x11f694
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x118280
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x11f71b
jnp 0x11f731
movq 0x28(%rsp), %rax
subq 0x18(%rsp), %rax
jge 0x11f750
movsd 0x1928f1(%rip), %xmm0   # 0x2b2020
jmp 0x11f78a
movq (%rbx), %rsi
leaq 0x19789f(%rip), %rdi    # 0x2b6fda
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x118080
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq 0x30(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, %xmm1
punpckldq 0x192a62(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x192a6a(%rip), %xmm1   # 0x2b21e0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x19289e(%rip), %xmm0   # 0x2b2028
movl %r13d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm0, %xmm1
movq (%rbx), %rsi
leaq 0x1977f6(%rip), %rdi    # 0x2b6f99
movb $0x2, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x118080
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: load_expression_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline std::size_t load_expression_file(const std::string& file_name, std::deque<std::string>& expression_list)
{
   std::ifstream stream(file_name.c_str());

   if (!stream) return 0;

   std::string buffer;
   buffer.reserve(1024);
   std::size_t line_count = 0;

   while (std::getline(stream,buffer))
   {
      if (buffer.empty())
         continue;
      else if ('#' == buffer[0])
         continue;

      ++line_count;
      expression_list.push_back(buffer);
   }

   return line_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x118050
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x11fc00
xorl %r14d, %r14d
jmp 0x11fc98
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x8(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x118410
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x118540
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x118030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11fc81
cmpq $0x0, 0x10(%rsp)
je 0x11fc2d
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
je 0x11fc2d
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1224bc
jmp 0x11fc2d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11fc98
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1180c0
leaq 0x28(%rsp), %rdi
callq 0x118040
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11fcba
jmp 0x11fcba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11fcd4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1180c0
leaq 0x28(%rsp), %rdi
callq 0x118040
movq %rbx, %rdi
callq 0x118340
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: GLUTSpecial(int, int, int)
void GLUTSpecial(int key, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Process keyboard button event 
  switch(key) {
  case GLUT_KEY_DOWN:
    if (current_mesh <= 1) current_mesh = 0;
    else current_mesh--;
    break;
    
  case GLUT_KEY_UP:
    if (current_mesh >= meshes.NEntries()-2) current_mesh = meshes.NEntries()-1;
    else current_mesh++;
    break;
  }
  
  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;

  // Remember modifiers 
  GLUTmodifiers = glutGetModifiers();

  // Redraw
  glutPostRedisplay();
}

// Assembly:
movl 0x116ccd(%rip), %eax    # 0x13d9bc
cmpl $0x65, %edi
je 0x26d0e
cmpl $0x67, %edi
jne 0x26d31
movl 0x116cb1(%rip), %edi    # 0x13d9b0
leal -0x1(%rdi), %r8d
xorl %ecx, %ecx
cmpl $0x2, %edi
cmovgel %r8d, %ecx
jmp 0x26d2b
movl 0x116c9c(%rip), %edi    # 0x13d9b0
movl 0x11bbda(%rip), %ecx    # 0x1428f4
leal -0x2(%rcx), %r8d
cmpl %r8d, %edi
jge 0x26d29
incl %edi
movl %edi, %ecx
jmp 0x26d2b
decl %ecx
movl %ecx, 0x116c7f(%rip)    # 0x13d9b0
pushq %rax
subl %edx, %eax
movl %esi, 0x11c2f6(%rip)    # 0x143030
movl %eax, 0x11c2f4(%rip)    # 0x143034
callq 0xd1d11
popq %rax
jmp 0xcce58
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Set world origin
  if (initial_world_origin != R3unknown_point) {
    world_origin = initial_world_origin;
  }
  else if (meshes.NEntries() > 0) {
    world_origin = meshes[0]->BBox().Centroid();
  }

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x11b5e0(%rip), %rdi    # 0x1428d0
leaq 0x11f1e9(%rip), %rsi    # 0x1464e0
callq 0x74d88
testl %eax, %eax
je 0x27310
leaq 0x11b5f1(%rip), %rdi    # 0x1428f8
leaq 0x11b5c2(%rip), %rsi    # 0x1428d0
jmp 0x27346
cmpl $0x0, 0x11b5dd(%rip)    # 0x1428f4
jle 0x2734b
movq 0x11b5c8(%rip), %rax    # 0x1428e8
movq (%rax), %rsi
movq 0xf8(%rsi), %rax
addq $0xf8, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x11b5b5(%rip), %rdi    # 0x1428f8
movq %rbx, %rsi
callq 0x74ffa
callq 0xd0113
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: ReadMeshes(gaps::RNArray<char*> const&)
int
ReadMeshes(const RNArray<char *>& mesh_names)
{
  // Read each mesh
  for (int i = 0; i < mesh_names.NEntries(); i++) {
    char *mesh_name = mesh_names[i];

    // Allocate mesh
    R3Mesh *mesh = new R3Mesh();
    assert(mesh);

    // Read mesh from file
    if (!mesh->ReadFile(mesh_name)) {
      delete mesh;
      return 0;
    }

    // Add mesh to list
    meshes.Insert(mesh);

    // Print statistics
    if (print_verbose) {
      printf("Read mesh from %s ...\n", mesh_name);
      printf("  # Faces = %d\n", mesh->NFaces());
      printf("  # Edges = %d\n", mesh->NEdges());
      printf("  # Vertices = %d\n", mesh->NVertices());
      fflush(stdout);
    }
  }

  // Return number of meshes
  return meshes.NEntries();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0xc(%rdi)
jle 0x2742e
movq %rdi, %rbx
leaq 0x11b573(%rip), %r14    # 0x1428e8
leaq 0xb2f27(%rip), %rbp     # 0xda2a3
xorl %r13d, %r13d
movq (%rbx), %rax
movq (%rax,%r13,8), %r12
movl $0x138, %edi            # imm = 0x138
callq 0x218b0
movq %rax, %r15
movq %rax, %rdi
callq 0x5072c
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0x27436
movl 0x11b53c(%rip), %edx    # 0x1428f4
movq %r14, %rdi
movq %r15, %rsi
callq 0x86eea
cmpb $0x1, 0x11bc9a(%rip)    # 0x143064
jne 0x2741e
leaq 0xb2e99(%rip), %rdi     # 0xda26c
movq %r12, %rsi
xorl %eax, %eax
callq 0x21080
movl 0x34(%r15), %esi
leaq 0xb2e9b(%rip), %rdi     # 0xda283
xorl %eax, %eax
callq 0x21080
movl 0x24(%r15), %esi
leaq 0xb2e99(%rip), %rdi     # 0xda293
xorl %eax, %eax
callq 0x21080
movl 0x14(%r15), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x21080
movq 0x115b0a(%rip), %rax    # 0x13cf20
movq (%rax), %rdi
callq 0x21a80
incq %r13
movslq 0xc(%rbx), %rax
cmpq %rax, %r13
jl 0x2737f
movl 0x11b4c0(%rip), %eax    # 0x1428f4
jmp 0x27441
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x138, %esi            # imm = 0x138
movq %r15, %rdi
callq 0x218d0
movq %rbx, %rdi
callq 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: main
int main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Read mesh
  if (!ReadMeshes(mesh_names)) exit(-1);

  // Create viewer
  viewer = CreateBirdsEyeViewer(meshes[0]);
  if (!viewer) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, 0xc(%rsp)
callq 0x27ad4
testl %eax, %eax
je 0x27a99
movl %ebp, %edi
movq %rbx, %rsi
callq 0x27468
testl %eax, %eax
je 0x27a99
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
callq 0x2717f
leaq 0x11af11(%rip), %rdi    # 0x142860
callq 0x27356
testl %eax, %eax
je 0x27a99
movq 0x11af85(%rip), %rax    # 0x1428e8
movl $0xf8, %esi
addq (%rax), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c5a4
movq %rbx, %rdi
callq 0x6cbf8
mulsd 0xb2698(%rip), %xmm0    # 0xda020
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0x11b6d3(%rip)    # 0x143068
jne 0x279f0
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6cdba
movsd 0xb26c2(%rip), %xmm0    # 0xda070
mulsd 0x10(%rsp), %xmm0
leaq 0x11aee5(%rip), %rsi    # 0x1428a0
leaq 0x30(%rsp), %rdi
callq 0x760c2
leaq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x756b3
leaq 0x11aea5(%rip), %rdi    # 0x142888
leaq 0x80(%rsp), %rsi
callq 0x74ffa
movsd 0xb2638(%rip), %xmm2    # 0xda030
movsd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm2
mulsd 0xb266e(%rip), %xmm3    # 0xda078
leaq 0x11ae77(%rip), %rsi    # 0x142888
leaq 0x11ae88(%rip), %rdx    # 0x1428a0
leaq 0x11ae99(%rip), %rcx    # 0x1428b8
leaq 0x80(%rsp), %rdi
movsd 0xb2631(%rip), %xmm0    # 0xda060
movapd %xmm0, %xmm1
callq 0x29528
movl 0x115f7a(%rip), %ecx    # 0x13d9b8
movl 0x115f77(%rip), %r8d    # 0x13d9bc
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a25e
movl $0xa8, %edi
callq 0x218b0
movq %rax, %r14
leaq 0x80(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x27b98
leaq 0x48(%rsp), %rdi
callq 0x6d3c4
movq %r14, 0x11b552(%rip)    # 0x142fd8
callq 0x272e4
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21ae0
jmp 0x27abd
movq %rax, %rbx
movl $0xa8, %esi
movq %r14, %rdi
callq 0x218d0
jmp 0x27ac0
jmp 0x27abd
jmp 0x27abd
jmp 0x27abd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6d3c4
movq %rbx, %rdi
callq 0x220a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_06.cc
// Function: main
int main(int argc, char const *argv[])
{
	// std::array<std::string, 3> sa = {"hello", "c++", "primer"};
	std::string sa[] = {"hello", "c++", "primer"};
	std::cout << *(begin_custom(sa) + 1) << std::endl;
	std::cout << *(end_custom(sa) - 1) << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd9c(%rip), %rsi       # 0x2004
leaq 0xd9a(%rip), %rdx       # 0x2009
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x13b4
leaq -0x60(%rbp), %r14
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd7c(%rip), %rsi       # 0x200a
leaq 0xd78(%rip), %rdx       # 0x200d
movq %r14, %rdi
callq 0x13b4
leaq -0x40(%rbp), %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xd5e(%rip), %rsi       # 0x200e
leaq 0xd5d(%rip), %rdx       # 0x2014
movq %r14, %rdi
callq 0x13b4
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq 0x2d0a(%rip), %rdi      # 0x3fd8
callq 0x10a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x2ccc(%rip), %rdi      # 0x3fd8
callq 0x10a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq $-0x60, %rbx
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x1356
movq (%r15), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %r15
addq $0x20, %rbx
jne 0x1342
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x136f
movq %rax, %r15
addq $-0x10, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x138a
movq (%r14), %rsi
incq %rsi
callq 0x1090
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x1376
jmp 0x13ac
movq %rax, %r15
leaq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10f0
movq %r15, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O3/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstExpr*)
string to_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMTS:
            return to_string((AstStmts*)ast);
        case AST_TYPE_STMT:
            return to_string((AstStmt*)ast);
        case AST_TYPE_ASSIGN:
            return to_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x9, %rax
ja 0x515a
leaq 0x7ebd(%rip), %rcx      # 0xd004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x543e
jmp 0x51c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x80fb(%rip), %rsi      # 0xd263
leaq 0x80fb(%rip), %rdx      # 0xd26a
movq %rbx, %rdi
callq 0xb494
jmp 0x51c7
movq %rbx, %rdi
callq 0x496b
jmp 0x51c7
movq %rbx, %rdi
callq 0x57a4
jmp 0x51c7
movq %rbx, %rdi
callq 0x5cbc
jmp 0x51c7
movq %rbx, %rdi
callq 0x557e
jmp 0x51c7
movq %rbx, %rdi
callq 0x51d1
jmp 0x51c7
movq %rbx, %rdi
callq 0x4b7d
jmp 0x51c7
movq %rbx, %rdi
callq 0x4ac1
jmp 0x51c7
movq %rbx, %rdi
callq 0x5691
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstStmts*)
string to_string(AstStmts* ast) {
    int size = ast->stmts.size();
    string output = "AstStmts([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x10(%rsi), %r13
subq 0x8(%rsi), %r13
movq %rdi, %rbx
shrq $0x3, %r13
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x7c57(%rip), %rsi      # 0xd20a
leaq 0x7c5a(%rip), %rdx      # 0xd214
callq 0xb494
testl %r13d, %r13d
jle 0x562b
leal -0x1(%r13), %eax
movslq %eax, %r12
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
leaq -0x50(%rbp), %rdi
callq 0x543e
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x560f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3240
cmpq %r12, %r15
jge 0x5623
movq %rbx, %rdi
leaq 0x7bf7(%rip), %rsi      # 0xd215
callq 0x33a0
incq %r15
cmpq %r15, %r13
jne 0x55d5
leaq 0x7be6(%rip), %rsi      # 0xd218
movq %rbx, %rdi
callq 0x33a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5650
jmp 0x5650
movq %rax, %r14
jmp 0x5671
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5671
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3240
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5689
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3240
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstBlock*)
string to_string(AstBlock* ast) {
    int size = ast->stmts.size();
    string output = "AstBlock([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x10(%rsi), %r13
subq 0x8(%rsi), %r13
movq %rdi, %rbx
shrq $0x3, %r13
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x7b55(%rip), %rsi      # 0xd21b
leaq 0x7b58(%rip), %rdx      # 0xd225
callq 0xb494
testl %r13d, %r13d
jle 0x573e
leal -0x1(%r13), %eax
movslq %eax, %r12
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
leaq -0x50(%rbp), %rdi
callq 0x543e
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5722
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3240
cmpq %r12, %r15
jge 0x5736
movq %rbx, %rdi
leaq 0x7ae4(%rip), %rsi      # 0xd215
callq 0x33a0
incq %r15
cmpq %r15, %r13
jne 0x56e8
leaq 0x7ad3(%rip), %rsi      # 0xd218
movq %rbx, %rdi
callq 0x33a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5763
jmp 0x5763
movq %rax, %r14
jmp 0x5784
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5784
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3240
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x579c
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3240
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstExpr*)
string to_expr_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMT:
            return to_expr_string((AstStmt*)ast);
        case AST_TYPE_STMTS:
            return to_expr_string((AstStmts*)ast);
        case AST_TYPE_ASSIGN:
            return to_expr_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_expr_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_expr_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_expr_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_expr_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_expr_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_expr_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x9, %rax
ja 0x5f57
leaq 0x70eb(%rip), %rcx      # 0xd02c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x5ffd
jmp 0x5ff3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x72fe(%rip), %rsi      # 0xd263
leaq 0x72fe(%rip), %rdx      # 0xd26a
movq %rbx, %rdi
callq 0xb494
jmp 0x5ff3
movsd 0x8(%rsi), %xmm0
movq 0xbfb6(%rip), %rsi      # 0x11f38
leaq 0x753e(%rip), %rcx      # 0xd4c7
movl $0x148, %edx            # imm = 0x148
movq %rbx, %rdi
movb $0x1, %al
callq 0xb1b9
jmp 0x5ff3
movq %rbx, %rdi
callq 0x6aec
jmp 0x5ff3
movq %rbx, %rdi
callq 0x6208
jmp 0x5ff3
movq %rbx, %rdi
callq 0x60b2
jmp 0x5ff3
movq %rbx, %rdi
callq 0x678d
jmp 0x5ff3
movq %rbx, %rdi
callq 0x63cd
jmp 0x5ff3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb26a
jmp 0x5ff3
movq %rbx, %rdi
callq 0x697b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq