LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Entry.cpp
// Function: Entry::Entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, ReplicaType)
Entry::Entry(string _value, int _timestamp, ReplicaType _replica){
	this->delimiter = ":";
	value = _value;
	timestamp = _timestamp;
	replica = _replica;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x29b6(%rip), %rsi      # 0x13c5d
movq %r15, %rdi
callq 0x34d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3170
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Entry.cpp
// Function: Entry::Entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Entry::Entry(string entry){
	vector<string> tuple;
	this->delimiter = ":";
	size_t pos = entry.find(delimiter);
	size_t start = 0;
	while (pos != string::npos) {
		string field = entry.substr(start, pos-start);
		tuple.push_back(field);
		start = pos + delimiter.size();
		pos = entry.find(delimiter, start);
	}
	tuple.push_back(entry.substr(start));

	value = tuple.at(0);
	timestamp = stoi(tuple.at(1));
	replica = static_cast<ReplicaType>(stoi(tuple.at(2)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rsi, %r15
leaq 0x28(%rdi), %r14
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x292a(%rip), %rsi      # 0x13c5d
movq %r14, %rdi
movq %r14, 0x20(%rsp)
callq 0x34d0
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3520
movq %rax, %r14
leaq 0x28(%rsp), %r13
movq %rsp, %rbp
cmpq $-0x1, %r14
je 0x113a4
movq %r14, %rcx
subq %r12, %rcx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x32e0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1157a
movq %r14, %r12
addq 0x30(%rbx), %r12
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movq %r12, %rdx
callq 0x3520
movq %rax, %r14
movq %r13, %rdi
callq 0x3120
jmp 0x1135b
leaq 0x28(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x32e0
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x11952
leaq 0x28(%rsp), %rdi
callq 0x3120
movq %rsp, %rdi
xorl %esi, %esi
callq 0x115a6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3170
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x115a6
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x115c7
movl %eax, 0x20(%rbx)
movq %rsp, %rdi
pushq $0x2
popq %rsi
callq 0x115a6
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x115c7
movl %eax, 0x24(%rbx)
movq %rsp, %rdi
callq 0x115e4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1143d
jmp 0x11438
jmp 0x11438
jmp 0x11438
movq %rax, %r15
jmp 0x1144a
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x3120
movq %rsp, %rdi
callq 0x115e4
movq 0x20(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(int, Address, MessageType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ReplicaType)
Message::Message(int _transID, Address _fromAddr, MessageType _type, string _key, string _value, ReplicaType _replica){
	this->delimiter = "::";
	transID = _transID;
	fromAddr = _fromAddr;
	type = _type;
	key = _key;
	value = _value;
	replica = _replica;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r13
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %r12d
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
andw $0x0, 0x4c(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, (%rsp)
leaq 0x58(%rdi), %rbp
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x1eaf(%rip), %rsi      # 0x13c5c
movq %rbp, %rdi
callq 0x34d0
leaq 0x48(%rbx), %rdi
movl %r12d, 0x50(%rbx)
movq %r15, %rsi
callq 0xac2e
movl %r14d, (%rbx)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3170
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3170
movl 0x50(%rsp), %eax
movl %eax, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x3120
movq (%rsp), %rdi
callq 0x3120
movq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(Message const&)
Message::Message(const Message& anotherMessage) {
	this->delimiter = anotherMessage.delimiter;
	this->fromAddr = anotherMessage.fromAddr;
	this->key = anotherMessage.key;
	this->replica = anotherMessage.replica;
	this->success = anotherMessage.success;
	this->transID = anotherMessage.transID;
	this->type = anotherMessage.type;
	this->value = anotherMessage.value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
andw $0x0, 0x4c(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x58(%rdi), %r13
movb %al, 0x68(%rdi)
addq $0x58, %rsi
movq %r13, %rdi
callq 0x3170
leaq 0x48(%r15), %rdi
leaq 0x48(%r14), %rsi
callq 0xac2e
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3170
movl 0x4(%r14), %eax
movl %eax, 0x4(%r15)
movb 0x54(%r14), %al
movb %al, 0x54(%r15)
movl 0x50(%r14), %eax
movl %eax, 0x50(%r15)
movl (%r14), %eax
movl %eax, (%r15)
addq $0x28, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x3170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(int, Address, MessageType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Message::Message(int _transID, Address _fromAddr, MessageType _type, string _key, string _value){
	this->delimiter = "::";
	transID = _transID;
	fromAddr = _fromAddr;
	type = _type;
	key = _key;
	value = _value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %r15d
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
andw $0x0, 0x4c(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, (%rsp)
leaq 0x58(%rdi), %r13
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x1cee(%rip), %rsi      # 0x13c5c
movq %r13, %rdi
callq 0x34d0
leaq 0x48(%rbx), %rdi
movl %r15d, 0x50(%rbx)
movq %r14, %rsi
callq 0xac2e
movl %ebp, (%rbx)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3170
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3170
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x3120
movq (%rsp), %rdi
callq 0x3120
movq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(int, Address, MessageType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Message::Message(int _transID, Address _fromAddr, MessageType _type, string _key){
	this->delimiter = "::";
	transID = _transID;
	fromAddr = _fromAddr;
	type = _type;
	key = _key;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %ebp
movq %rdx, %r13
movq %rdi, %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %ebx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %r14
andw $0x0, 0x4c(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x58(%rdi), %r15
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x1c14(%rip), %rsi      # 0x13c5c
movq %r15, %rdi
callq 0x34d0
leaq 0x48(%r12), %rdi
movl %ebx, 0x50(%r12)
movq %r13, %rsi
callq 0xac2e
movl %ebp, (%r12)
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x3170
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3120
movq 0x8(%rsp), %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(int, Address, MessageType, bool)
Message::Message(int _transID, Address _fromAddr, MessageType _type, bool _success){
	this->delimiter = "::";
	transID = _transID;
	fromAddr = _fromAddr;
	type = _type;
	success = _success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %r13d
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rsp)
andw $0x0, 0x4c(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x58(%rdi), %r15
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x1b40(%rip), %rsi      # 0x13c5c
movq %r15, %rdi
callq 0x34d0
leaq 0x48(%r14), %rdi
movl %r13d, 0x50(%r14)
movq %r12, %rsi
callq 0xac2e
movl %ebp, (%r14)
movb %bl, 0x54(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3120
movq 0x8(%rsp), %rdi
callq 0x3120
movq 0x10(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::Message(int, Address, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Message::Message(int _transID, Address _fromAddr, string _value){
	this->delimiter = "::";
	transID = _transID;
	fromAddr = _fromAddr;
	type = READREPLY;
	value = _value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movq %rdi, %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %r14d
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, (%rsp)
andw $0x0, 0x4c(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x58(%rdi), %rbp
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x1a81(%rip), %rsi      # 0x13c5c
movq %rbp, %rdi
callq 0x34d0
leaq 0x48(%r12), %rdi
movl %r14d, 0x50(%r12)
movq %r13, %rsi
callq 0xac2e
movl $0x5, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3120
movq (%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Message.cpp
// Function: Message::operator=(Message const&)
Message& Message::operator =(const Message& anotherMessage) {
	this->delimiter = anotherMessage.delimiter;
	this->fromAddr = anotherMessage.fromAddr;
	this->key = anotherMessage.key;
	this->replica = anotherMessage.replica;
	this->success = anotherMessage.success;
	this->transID = anotherMessage.transID;
	this->type = anotherMessage.type;
	this->value = anotherMessage.value;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x58, %rsi
addq $0x58, %rdi
callq 0x3170
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0xac2e
leaq 0x8(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x3170
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movb 0x54(%r14), %al
movb %al, 0x54(%rbx)
movl 0x50(%r14), %eax
movl %eax, 0x50(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
addq $0x28, %r14
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x3170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/./Member.h
// Function: Address::Address(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Address(string address) {
		size_t pos = address.find(":");
		int id = stoi(address.substr(0, pos));
		short port = (short)stoi(address.substr(pos + 1, address.size()-pos-1));
		memcpy(&addr[0], &id, sizeof(int));
		memcpy(&addr[4], &port, sizeof(short));
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16d0(%rip), %rsi      # 0x13c5d
movq %r14, %rdi
xorl %edx, %edx
callq 0x3510
movq %rax, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x32e0
pushq $0xa
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x115c7
movl %eax, %ebp
movq %rsp, %rdi
callq 0x3120
leaq 0x1(%r15), %rdx
notq %r15
addq 0x8(%r14), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x32e0
pushq $0xa
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x115c7
movl %eax, %r14d
movq %rsp, %rdi
callq 0x3120
movl %ebp, (%rbx)
movw %r14w, 0x4(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1260e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./test/main.cpp
// Function: main
int main(int argc, char* argv[])
{


	Thread::threadManager* manage = new Thread::threadManager(10);  

	sleep(2);  
	for(int i=0;i<10000;i++)  
	{  
/*		
		usleep(10);
		JobData *data = new JobData();
		memset(data->message,'0',1024);
        sprintf(data->message,"message %d",i);		
		CYJob * job = new CYJob();  
		manage->Run(job,data);  
*/
		sleep(1);
		char buffer[1024];
		Common::getCurStr(buffer);
		printf("%s\r\n",buffer);
	}  

    while(1)
	{
	   sleep(1);
	}

	manage->StopAll(); 
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
pushq $0x18
popq %rdi
callq 0x2130
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x2660
pushq $0x2
popq %rdi
callq 0x20e0
movl $0x2710, %ebp           # imm = 0x2710
pushq $0x1
popq %rbx
movq %rsp, %r14
leaq 0x1c6b(%rip), %r15      # 0x4004
subl $0x1, %ebp
jb 0x23bc
movl %ebx, %edi
callq 0x20e0
movq %r14, %rdi
callq 0x242b
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x2399
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x20e0
jmp 0x23bf
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/thread.cpp
// Function: Thread::thread::Start()
void thread::Start()
	{
		pthread_attr_t attr;
		pthread_attr_init(&attr); 
		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 
		if (pthread_create(&_tid,&attr,thread::ThreadFunction,this)!=0) {
			printf("Create thread error!\n");
			return ;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2180
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x2190
leaq 0x8(%rbx), %rdi
leaq -0x37(%rip), %rdx       # 0x24fc
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2240
testl %eax, %eax
je 0x254e
leaq 0x1af4(%rip), %rdi      # 0x403d
callq 0x21f0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadJob.cpp
// Function: Thread::threadJob::setJobName(char*)
void threadJob::setJobName(char* jobName)
	{
         if(_jobName != NULL)
		 {
		    free(_jobName);
			_jobName = NULL;
		 }

		 if(jobName != NULL)
		 {
		      _jobName = (char*)malloc(strlen(jobName)+1);
			  strcpy(_jobName,jobName);
		 }
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x25b5
callq 0x2160
andq $0x0, 0x18(%r14)
testq %rbx, %rbx
je 0x25e1
movq %rbx, %rdi
callq 0x20a0
leaq 0x1(%rax), %rdi
callq 0x21a0
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2120
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::threadPool(int)
threadPool::threadPool(int num)
		:_num(num),
		 _allNum(0),
		 _idleNum(0),
		 _busyNum(0),
	     _busyMutex(),
		 _idleMutex(),
		 _busyCond(_busyMutex),
		 _idleCond(_idleMutex)

	{
		_workBusyVec.clear();
		_workIdleVec.clear();

		for(int i=0; i< _num; i++)
		{
		   threadWork* work = new threadWork(this);
		   __appendIdleThread(work);
		   work->Start();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r13
leaq 0x4654(%rip), %rax      # 0x6d68
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
andq $0x0, 0xc(%rdi)
andl $0x0, 0x14(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x2490
leaq 0x40(%r13), %r14
movq %r14, %rdi
callq 0x2490
leaq 0x68(%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24c2
movq %r15, 0x20(%rsp)
leaq 0xa0(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x24c2
leaq 0xd8(%r13), %rax
movq %rax, 0x18(%rsp)
leaq 0xf0(%r13), %rax
movq %rax, 0x10(%rsp)
leaq 0x108(%r13), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%r13)
movups %xmm0, 0xf8(%r13)
movups %xmm0, 0xe8(%r13)
movups %xmm0, 0xd8(%r13)
andq $0x0, 0x118(%r13)
xorl %r15d, %r15d
cmpl 0x8(%r13), %r15d
jge 0x27e9
movl $0xb8, %edi
callq 0x2130
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
callq 0x3004
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2864
movq %rbp, %rdi
callq 0x2508
incl %r15d
jmp 0x27b3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x2842
movq %rax, %r13
jmp 0x284c
movq %rax, %r13
jmp 0x2854
movq %rax, %r13
movl $0xb8, %esi
movq %rbp, %rdi
callq 0x2140
jmp 0x281c
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x2dfe
movq 0x10(%rsp), %rdi
callq 0x2dfe
movq 0x18(%rsp), %rdi
callq 0x2dfe
movq %r12, %rdi
callq 0x24ce
movq 0x20(%rsp), %rdi
callq 0x24ce
movq %r14, %rdi
callq 0x2498
movq %rbx, %rdi
callq 0x2498
movq %r13, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__appendIdleThread(Thread::threadWork*)
void threadPool::__appendIdleThread(threadWork* jobThread)
		{
			_idleMutex.lock(__FUNCTION__,__LINE__);

			_workAllVec.push_back(jobThread);
			_workIdleVec.push_back(jobThread);
			_allNum++;
			_idleNum++;
			_idleMutex.unlock(__FUNCTION__,__LINE__);
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x40(%rdi), %r15
leaq 0x186c(%rip), %r12      # 0x40ec
pushq $0x6d
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x24a2
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x2de0
leaq 0x108(%rbx), %rdi
movq %r14, %rsi
callq 0x2de0
movq 0xc(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0xc(%rbx)
pushq $0x73
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x24a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::StopAll()
void threadPool::StopAll()
	{
		for(unsigned int i=0; i< _workAllVec.size(); i++)
		{
		   threadWork* work = _workAllVec[i];
		   work->Stop();
		}
		
		_workAllVec.clear();
		_workBusyVec.clear();
		_workIdleVec.clear();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, %r14d
movq 0xd8(%rbx), %rax
movq 0xe0(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x297a
movq (%rax,%r14,8), %rdi
callq 0x2556
leal 0x1(%r14), %eax
jmp 0x294b
cmpq %rax, %rcx
je 0x2986
movq %rax, 0xe0(%rbx)
movq 0xf0(%rbx), %rax
cmpq %rax, 0xf8(%rbx)
je 0x299d
movq %rax, 0xf8(%rbx)
movq 0x108(%rbx), %rax
cmpq %rax, 0x110(%rbx)
je 0x29b4
movq %rax, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::Run(Thread::threadJob*, void*)
void threadPool::Run(threadJob* job, void* argv)
	{
		assert(job != NULL);
       
//		_busyMutex.lock(__FUNCTION__,__LINE__);
		if(_busyNum == _allNum)
			_busyCond.wait();

		threadWork *idleThread = __getIdleThread();
		if(idleThread != NULL)
		{
		    idleThread->_workMutex.lock(__FUNCTION__,__LINE__);
			__idleMove2Busy(idleThread);
			job->setWorkThread(idleThread);
			idleThread->setJob(job, argv);
		}
//		_busyMutex.unlock(__FUNCTION__,__LINE__);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2a5c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x14(%rdi), %eax
cmpl 0xc(%rdi), %eax
jne 0x29fb
leaq 0x68(%r15), %rdi
callq 0x24d4
movq %r15, %rdi
callq 0x2a7a
testq %rax, %rax
je 0x2a50
movq %rax, %r12
movq %rax, %rdi
addq $0x58, %rdi
leaq 0x16bc(%rip), %rsi      # 0x40d5
pushq $0x2e
popq %rdx
callq 0x24a2
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ad8
movq %r14, %rdi
movq %r12, %rsi
callq 0x2606
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x161c(%rip), %rdi      # 0x407f
leaq 0x1621(%rip), %rsi      # 0x408b
leaq 0x1632(%rip), %rcx      # 0x40a3
pushq $0x25
popq %rdx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__getIdleThread()
threadWork* threadPool::__getIdleThread()
		{
			_idleMutex.lock(__FUNCTION__,__LINE__);
			while(_workIdleVec.size() == 0)
				_idleCond.wait();

			if(_workIdleVec.size() > 0)
			{
				threadWork *work = _workIdleVec.front();
				_idleMutex.unlock(__FUNCTION__,__LINE__);
				return work;
			}

			_idleMutex.unlock(__FUNCTION__,__LINE__);
			return NULL;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
leaq 0x1672(%rip), %rsi      # 0x40ff
pushq $0x78
popq %rdx
movq %rbx, %rdi
callq 0x24a2
leaq 0xa0(%r14), %r15
movq 0x108(%r14), %rax
cmpq %rax, 0x110(%r14)
jne 0x2ab9
movq %r15, %rdi
callq 0x24d4
jmp 0x2a9f
movq (%rax), %r14
leaq 0x163c(%rip), %rsi      # 0x40ff
pushq $0x7f
popq %rdx
movq %rbx, %rdi
callq 0x24a8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__idleMove2Busy(Thread::threadWork*)
void threadPool::__idleMove2Busy(threadWork* idleThread)
	{
		_busyMutex.lock(__FUNCTION__,__LINE__);
		_workBusyVec.push_back(idleThread);
		_busyNum++;
		_busyMutex.unlock(__FUNCTION__,__LINE__);


		_idleMutex.lock(__FUNCTION__,__LINE__);
		std::vector<threadWork *>::iterator pos;
		pos = find(_workIdleVec.begin(), _workIdleVec.end(), idleThread);
		if(pos != _workIdleVec.end())
		{
			_workIdleVec.erase(pos);
			_idleNum--;
		}
		_idleMutex.unlock(__FUNCTION__,__LINE__);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x18(%rdi), %r15
leaq 0x162b(%rip), %r12      # 0x411f
movq %r15, %rdi
movq %r12, %rsi
movl $0xa0, %edx
callq 0x24a2
leaq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x2de0
incl 0x14(%rbx)
movq %r15, %rdi
movq %r12, %rsi
movl $0xa3, %edx
callq 0x24a8
leaq 0x40(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0xa6, %edx
callq 0x24a2
movq 0x108(%rbx), %rdi
movq 0x110(%rbx), %rsi
movq %r14, %rdx
callq 0x2e31
cmpq 0x110(%rbx), %rax
je 0x2b6b
leaq 0x108(%rbx), %rdi
movq %rax, %rsi
callq 0x2da6
decl 0x10(%rbx)
leaq 0x15ad(%rip), %rsi      # 0x411f
movq %r15, %rdi
movl $0xae, %edx
callq 0x24a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__createIdleThread(int)
void threadPool::__createIdleThread(int num)
	{
		for(int i=0; i< num; i++)
		{
		   threadWork* work = new threadWork(this);
		   __appendIdleThread(work);
		   work->Start();
		}
		_num = _num + num;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
subl $0x1, %ebp
jb 0x2bd1
movl $0xb8, %edi
callq 0x2130
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3004
movq %r14, %rdi
movq %r15, %rsi
callq 0x2864
movq %r15, %rdi
callq 0x2508
jmp 0x2b9f
addl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__deleteIdleThread(int)
void  threadPool::__deleteIdleThread(int num)
	{
		_idleMutex.lock(__FUNCTION__,__LINE__);
		for(int i=0; i < num; i++)
		{
			if(_workIdleVec.size() > 0)
			{
				threadWork *removeThread = _workIdleVec.front();
				std::vector<threadWork *>::iterator pos;
				pos = std::find(_workIdleVec.begin(), _workIdleVec.end(), removeThread);
				if(pos != _workIdleVec.end())
				{
					_workIdleVec.erase(pos);
					_idleNum--;
				}

				std::vector<threadWork *>::iterator posTemp;
				posTemp = find(_workAllVec.begin(), _workAllVec.end(), removeThread);
				if(posTemp != _workAllVec.end())
				{
					_workAllVec.erase(posTemp);
					_allNum--;
				}

			}
		}
		_idleMutex.unlock(__FUNCTION__,__LINE__);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
addq $0x40, %rdi
leaq 0x14c3(%rip), %rsi      # 0x40d9
pushq $0x50
popq %rdx
movq %rdi, 0x8(%rsp)
callq 0x24a2
leaq 0x108(%r14), %r15
leaq 0xd8(%r14), %r12
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
leaq 0x10(%rsp), %r13
subl $0x1, %ebx
jb 0x2cad
movq 0x108(%r14), %rdi
movq 0x110(%r14), %rsi
cmpq %rdi, %rsi
je 0x2c3d
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdx
callq 0x2e31
cmpq 0x110(%r14), %rax
je 0x2c7d
movq %r15, %rdi
movq %rax, %rsi
callq 0x2da6
decl 0x10(%r14)
movq 0xd8(%r14), %rdi
movq 0xe0(%r14), %rsi
movq %r13, %rdx
callq 0x2e31
cmpq 0xe0(%r14), %rax
je 0x2c3d
movq %r12, %rdi
movq %rax, %rsi
callq 0x2da6
decl 0xc(%r14)
jmp 0x2c3d
leaq 0x1425(%rip), %rsi      # 0x40d9
pushq $0x68
popq %rdx
movq 0x8(%rsp), %rdi
callq 0x24a8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__busyMove2Idle(Thread::threadWork*)
void threadPool::__busyMove2Idle(threadWork* busyThread)
	{

		_idleMutex.lock(__FUNCTION__,__LINE__);
		_workIdleVec.push_back(busyThread);
		_idleNum++;
		_idleMutex.unlock(__FUNCTION__,__LINE__);


		_busyMutex.lock(__FUNCTION__,__LINE__);
		std::vector<threadWork *>::iterator pos;
		pos = find(_workBusyVec.begin(), _workBusyVec.end(), busyThread);
		if(pos != _workBusyVec.end())
		{
			_workBusyVec.erase(pos);
			_busyNum--;
		}
		_busyMutex.unlock(__FUNCTION__,__LINE__);

        _idleCond.notify();
        _busyCond.notify();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x40(%rdi), %r15
leaq 0x1423(%rip), %r12      # 0x410f
movq %r15, %rdi
movq %r12, %rsi
movl $0x8a, %edx
callq 0x24a2
leaq 0x108(%rbx), %rdi
movq %r14, %rsi
callq 0x2de0
incl 0x10(%rbx)
movq %r15, %rdi
movq %r12, %rsi
movl $0x8d, %edx
callq 0x24a8
leaq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x90, %edx
callq 0x24a2
movq 0xf0(%rbx), %rdi
movq 0xf8(%rbx), %rsi
movq %r14, %rdx
callq 0x2e31
cmpq 0xf8(%rbx), %rax
je 0x2d63
leaq 0xf0(%rbx), %rdi
movq %rax, %rsi
callq 0x2da6
decl 0x14(%rbx)
leaq 0x13a5(%rip), %rsi      # 0x410f
movq %r15, %rdi
movl $0x98, %edx
callq 0x24a8
leaq 0xa0(%rbx), %rdi
callq 0x24de
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x24de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::~threadWork()
threadWork::~threadWork()
	{
		_argv = NULL;
        if(_job != NULL)
		{
		  delete _job ;
		}
		_pool = NULL;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3d01(%rip), %rax      # 0x6d98
movq %rax, (%rdi)
andq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x30ae
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x18(%rbx)
leaq 0x80(%rbx), %rdi
callq 0x24ce
leaq 0x58(%rbx), %rdi
callq 0x2498
leaq 0x30(%rbx), %rdi
callq 0x2498
movq %rbx, %rdi
popq %rbx
jmp 0x24f8
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::Run()
void threadWork::Run()
	{
        for(;;)
		{
		  
           _workMutex.lock(__FUNCTION__,__LINE__);
		   while(_job == NULL)
		   {
			   _workCond.wait();
		   }

		   _job->Run(_argv);

		   _job->setWorkThread(NULL);
		   _job = NULL;
		   _pool->__busyMove2Idle(this);

           	_workMutex.unlock(__FUNCTION__,__LINE__);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
leaq 0x80(%rdi), %r15
leaq 0xfc3(%rip), %r12       # 0x40d5
pushq $0x21
popq %rbp
pushq $0x2d
popq %r13
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x24a2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x3139
movq %r15, %rdi
callq 0x24d4
jmp 0x3126
movq 0x28(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x2606
andq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x2cd0
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x24a8
jmp 0x3119
nop
// File: /workspace/github_cpp_makefile_star2_O2/tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::setJob(Thread::threadJob*, void*)
void threadWork::setJob(threadJob* job, void* argv)
	{
        _varMutex.lock(__FUNCTION__,__LINE__);
		_job = job;
		_argv = argv;
		_job->setWorkThread(this);
        _varMutex.unlock(__FUNCTION__,__LINE__);
        
		_workCond.notify();
        _workMutex.unlock(__FUNCTION__,__LINE__);

	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
leaq 0xfd2(%rip), %r13       # 0x415f
pushq $0x33
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x24a2
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2606
pushq $0x37
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x24a8
leaq 0x80(%rbx), %rdi
callq 0x24de
addq $0x58, %rbx
pushq $0x3a
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24a8
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::log<char [4]>(char const (&) [4])
void ConsoleLogger::log(const Args&... args)
{
	if (loglevel > 0) return;
	mtx.lock();
	out << "    ";
	print(args...);
	mtx.unlock();
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x2639
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe0(%rdi), %r15
movq %r15, %rdi
callq 0x281a
movq (%r14), %rdi
leaq 0x29be(%rip), %rsi      # 0x5020
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2830
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::info<char [21]>(char const (&) [21])
void ConsoleLogger::info(const Args&... args)
{
	if (loglevel > 1) return;
	mtx.lock();
	if (colored) out << infoColor;
	out << "[i] ";
	if (colored) out << "\033[0m";
	print(args...);
	mtx.unlock();
}

// Assembly:
cmpl $0x1, 0x6c(%rdi)
jle 0x2b6b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe0(%rdi), %r15
movq %r15, %rdi
callq 0x281a
cmpb $0x1, 0x68(%r14)
jne 0x2b9d
movq (%r14), %rdi
leaq 0x8(%r14), %rsi
callq 0x2150
movq (%r14), %rdi
leaq 0x25a2(%rip), %rsi      # 0x5149
callq 0x2170
cmpb $0x1, 0x68(%r14)
jne 0x2bc2
movq (%r14), %rdi
leaq 0x2555(%rip), %rsi      # 0x5112
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3fac
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::warn<char [23]>(char const (&) [23])
void ConsoleLogger::warn(const Args&... args)
{
	if (loglevel > 2) return;
	mtx.lock();
	if (colored) out << warnColor;
	out << "[!] ";
	print(args...);
	if (colored) out << "\033[0m";
	mtx.unlock();
}

// Assembly:
cmpl $0x2, 0x6c(%rdi)
jle 0x2be7
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe0(%rdi), %rbx
movq %rbx, %rdi
callq 0x281a
cmpb $0x1, 0x68(%r14)
jne 0x2c19
movq (%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0x2150
movq (%r14), %rdi
leaq 0x24ea(%rip), %rsi      # 0x510d
callq 0x2170
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fcc
cmpb $0x1, 0x68(%r14)
jne 0x2c49
movq (%r14), %rdi
leaq 0x24ce(%rip), %rsi      # 0x5112
callq 0x2170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::error<char [23]>(char const (&) [23])
void ConsoleLogger::error(const Args&... args)
{
	if (loglevel > 3) return;
	mtx.lock();
	if (colored) out << errorColor;
	out << "[X] ";
	print(args...);
	if (colored) out << "\033[0m";
	mtx.unlock();
}

// Assembly:
cmpl $0x3, 0x6c(%rdi)
jle 0x2c63
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe0(%rdi), %rbx
movq %rbx, %rdi
callq 0x281a
cmpb $0x1, 0x68(%r14)
jne 0x2c95
movq (%r14), %rdi
leaq 0x48(%r14), %rsi
callq 0x2150
movq (%r14), %rdi
leaq 0x24af(%rip), %rsi      # 0x514e
callq 0x2170
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fcc
cmpb $0x1, 0x68(%r14)
jne 0x2cc5
movq (%r14), %rdi
leaq 0x2452(%rip), %rsi      # 0x5112
callq 0x2170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::debug<char [43]>(char const (&) [43])
void ConsoleLogger::debug(const Args&... args)
{
#ifndef NDEBUG
	mtx.lock();
	out << "... ";
	print(args...);
	mtx.unlock();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe0(%rdi), %r15
movq %r15, %rdi
callq 0x281a
movq (%r14), %rdi
leaq 0x2452(%rip), %rsi      # 0x5153
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3fec
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void ConsoleLogger::time(const std::string& label)
{
	if (starttimes.count(label))
	{
		warn("Timer \"" + label + "\" already exists.");
		return;
	}
	mtx.lock();
	starttimes[label] = std::chrono::system_clock::now();
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rdi), %r15
movq %r15, %rdi
callq 0x348a
testq %rax, %rax
je 0x2f78
leaq 0x21c8(%rip), %rsi      # 0x50f3
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x3414
leaq 0x21ba(%rip), %rdx      # 0x50fb
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x33eb
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3370
leaq -0x40(%rbp), %rdi
callq 0x20d0
leaq -0x60(%rbp), %rdi
callq 0x20d0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0xe0, %rbx
movq %rbx, %rdi
callq 0x281a
callq 0x2030
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x35f6
movq %r12, (%rax)
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2120
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x2fc2
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::timeEnd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void ConsoleLogger::timeEnd(const std::string& label)
{
	if (!starttimes.count(label))
	{
		warn("Timer \"" + label + "\" doesn't exist.");
		return;
	}
	mtx.lock();
	auto now = std::chrono::system_clock::now();
	std::chrono::duration<double> seconds = now - starttimes[label];
	if (loglevel <= 0)
		out << "    "+label+": " << 0.001*round(seconds.count()*1000) << "s - timer ended" << std::endl;
	starttimes.erase(label);
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x348a
testq %rax, %rax
je 0x30db
leaq 0xe0(%r12), %r15
movq %r15, %rdi
callq 0x281a
callq 0x2030
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35f6
cmpl $0x0, 0x6c(%r12)
jg 0x30c6
subq (%rax), %r13
movq (%r12), %rax
movq %rax, -0x30(%rbp)
leaq 0x1fdf(%rip), %rsi      # 0x5020
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x3414
leaq 0x20d1(%rip), %rdx      # 0x5128
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x33eb
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2150
movq %rax, %r12
cvtsi2sd %r13, %xmm0
divsd 0x1fa8(%rip), %xmm0     # 0x5028
mulsd 0x1fa8(%rip), %xmm0     # 0x5030
callq 0x20a0
mulsd 0x1fa3(%rip), %xmm0     # 0x5038
movq %r12, %rdi
callq 0x2230
leaq 0x2087(%rip), %rsi      # 0x512b
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39d8
movq %r15, %rdi
callq 0x2120
jmp 0x3122
leaq 0x2011(%rip), %rsi      # 0x50f3
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3414
leaq 0x201f(%rip), %rdx      # 0x5117
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x33eb
leaq -0x50(%rbp), %rsi
movq %r12, %rdi
callq 0x3370
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x70(%rbp), %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3135
jmp 0x313a
movq %rax, %rbx
jmp 0x3146
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline long long ConsoleLogger::count(const std::string& label)
{
	mtx.lock();
	int t = ++counts[label];
	if (loglevel <= 0)
		out << "    "+label+": " << t << std::endl;
	mtx.unlock();
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0xe0(%rdi), %rbx
movq %rbx, %rdi
callq 0x281a
leaq 0xa8(%r12), %rdi
movq %r15, %rsi
callq 0x3aec
movq (%rax), %r14
incq %r14
movq %r14, (%rax)
cmpl $0x0, 0x6c(%r12)
jg 0x31fd
movq (%r12), %r12
leaq 0x1e76(%rip), %rsi      # 0x5020
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r15, %rdx
callq 0x3414
leaq 0x1f68(%rip), %rdx      # 0x5128
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x33eb
leaq -0x48(%rbp), %rsi
movq %r12, %rdi
callq 0x2150
movq %rax, %rdi
movl %r14d, %esi
callq 0x2260
movq %rax, %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2120
movslq %r14d, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3228
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::countReset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline long long ConsoleLogger::countReset(const std::string& label)
{
	if (!counts.count(label))
	{
		mtx.lock();
		warn("Counter \"" + label + "\" doesn't exist.");
		mtx.unlock();
		return -1;
	}
	mtx.lock();
	counts[label] = 0;
	if (loglevel <= 0)
		out << "    "+label+": 0" << std::endl;
	mtx.unlock();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa8(%rdi), %r12
movq %r12, %rdi
callq 0x3f48
movq %rax, %r13
leaq 0xe0(%r14), %rbx
movq %rbx, %rdi
callq 0x281a
testq %r13, %r13
je 0x32e4
movq %r12, %rdi
movq %r15, %rsi
callq 0x3aec
andq $0x0, (%rax)
cmpl $0x0, 0x6c(%r14)
jg 0x32df
movq (%r14), %r14
leaq 0x1d89(%rip), %rsi      # 0x5020
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x3414
leaq 0x1e98(%rip), %rdx      # 0x5145
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x33eb
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
xorl %r14d, %r14d
jmp 0x332f
leaq 0x1e50(%rip), %rsi      # 0x513b
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x3414
leaq 0x1e16(%rip), %rdx      # 0x5117
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x33eb
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x3370
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
pushq $-0x1
popq %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x334d
jmp 0x3352
movq %rax, %rbx
jmp 0x335e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/111116[P]console/example_advanced.cpp
// Function: std::ostream& std::operator<<<int>(std::ostream&, std::vector<int, std::allocator<int>> const&)
std::ostream& operator<< (std::ostream& os, const std::vector<T>& v)
	{
		os << '[';
		if (!v.empty()) os << v[0];
		for (int i=1; i<v.size(); ++i)
			os << ',' << v[i];
		return os << ']';
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x5b
popq %rsi
callq 0x21a0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x420f
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2260
pushq $0x1
popq %r12
pushq $0x2c
popq %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x4246
movq %rbx, %rdi
movl %r15d, %esi
callq 0x21a0
movq (%r14), %rcx
movl (%rcx,%r12,4), %esi
movq %rax, %rdi
callq 0x2260
incq %r12
jmp 0x4217
pushq $0x5d
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aalto-speech[P]ftk/src/iterate12.cc
// Function: prune_msfg(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, MultiStringFactorGraph&)
void prune_msfg(const map<string, flt_type> &vocab,
                MultiStringFactorGraph &msfg)
{
    if (vocab.size() < msfg.factor_node_map.size()) {
        vector<string> to_remove;
        cerr << "Pruning " << msfg.factor_node_map.size()-vocab.size() << " unused transitions from msfg." << endl;
        for (auto it = msfg.factor_node_map.begin(); it != msfg.factor_node_map.end(); ++it)
            if (vocab.find(it->first) == vocab.end())
                to_remove.push_back(it->first);
        for (auto it = to_remove.begin(); it != to_remove.end(); ++it)
            msfg.remove_arcs(*it);
        cerr << "Removed " << to_remove.size() << " subwords" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x28(%rdi), %rax
cmpq 0xc0(%rsi), %rax
jae 0x4c5d
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movq 0x3146f(%rip), %rdi     # 0x35fe8
leaq 0x1f4a2(%rip), %rsi     # 0x24022
callq 0x4340
movq 0xc0(%rbx), %rsi
subq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x1f48c(%rip), %rsi     # 0x2402b
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x4180
movq 0xb0(%rbx), %r15
movq %rbx, -0x48(%rbp)
leaq 0xa0(%rbx), %r12
leaq 0x8(%r14), %rbx
cmpq %r12, %r15
je 0x4bf7
leaq 0x20(%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x72b8
cmpq %rbx, %rax
jne 0x4bea
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x5b34
movq %r15, %rdi
callq 0x4270
movq %rax, %r15
jmp 0x4bc5
movq -0x40(%rbp), %r14
movq -0x48(%rbp), %rbx
cmpq -0x38(%rbp), %r14
je 0x4c16
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12772
addq $0x20, %r14
jmp 0x4bff
movq 0x313cb(%rip), %rdi     # 0x35fe8
leaq 0x1f426(%rip), %rsi     # 0x2404a
callq 0x4340
movq -0x38(%rbp), %rsi
subq -0x40(%rbp), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x1f40f(%rip), %rsi     # 0x24053
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x4180
leaq -0x40(%rbp), %rdi
callq 0x5b70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c72
jmp 0x4c72
jmp 0x4c72
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5b70
movq %rbx, %rdi
callq 0x45f0