LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::createKeyValue(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)
bool MP2Node::createKeyValue(string key, string value, ReplicaType replica) {
	// Insert key, value, replicaType into the hash table
	Entry entry(value, this->par->getcurrtime(), replica);
	auto res = ht->create(key, entry.convertToString());
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdx, -0xf8(%rbp)
movq %rsi, %rax
movq -0xf8(%rbp), %rsi
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4160
movq -0xe8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x18c60
movl %eax, -0xdc(%rbp)
jmp 0x1fed1
movl -0xdc(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x28810
jmp 0x1feec
leaq -0x88(%rbp), %rdi
callq 0x4200
movq -0xe8(%rbp), %rax
movq -0xf0(%rbp), %rsi
movq 0x48(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4160
jmp 0x1ff1f
leaq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x28b40
jmp 0x1ff31
movq -0x100(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x26430
movb %al, -0x101(%rbp)
jmp 0x1ff53
leaq -0xd8(%rbp), %rdi
callq 0x4200
leaq -0xb8(%rbp), %rdi
callq 0x4200
movb -0x101(%rbp), %al
andb $0x1, %al
movb %al, -0x95(%rbp)
movb -0x95(%rbp), %al
movb %al, -0x102(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x22000
movb -0x102(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4200
jmp 0x2001a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x20011
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x20005
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4200
leaq -0xb8(%rbp), %rdi
callq 0x4200
leaq -0x68(%rbp), %rdi
callq 0x22000
movq -0x90(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::readKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string MP2Node::readKey(string key) {
	// Read key from local hash table and return value
	auto val = ht->read(key);
	if (val.empty()) {
	    return val;
	}
	Entry entry(val);
	return entry.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf8(%rbp)
movq %rsi, %rax
movq -0xf8(%rbp), %rsi
movq %rdi, -0xf0(%rbp)
movq %rdi, %rcx
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x4160
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x26470
jmp 0x200a1
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x38(%rbp), %rdi
callq 0x4580
testb $0x1, %al
jne 0x200b9
jmp 0x200ef
movq -0xf0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41d0
movl $0x1, -0x68(%rbp)
jmp 0x2018e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
jmp 0x201b0
leaq -0xd0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4160
jmp 0x20101
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x288b0
jmp 0x20116
leaq -0xd0(%rbp), %rdi
callq 0x4200
movq -0xf0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x4160
jmp 0x20137
movl $0x1, -0x68(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x22000
jmp 0x2018e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x201a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4200
jmp 0x201a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x22000
jmp 0x201a7
leaq -0x38(%rbp), %rdi
callq 0x4200
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::handleReplyMessage(Message)
void MP2Node::handleReplyMessage(Message msg) {
    int txId = msg.transID;
    auto it = txMap.find(txId);

    if (it != txMap.end()) {
        Transaction *transaction = &it->second;

        transaction->totalCount++;
        // READREPLY messages don't use success field, they use value field instead (if fail value is null)
        // see Message(string str) constructor
        if (msg.type == READREPLY && !msg.value.empty()) {
            transaction->successCount++;
            transaction->value = msg.value;
        } else if (msg.success) {
            transaction->successCount++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl 0x50(%rsi), %eax
movl %eax, -0x14(%rbp)
addq $0xc0, %rdi
leaq -0x14(%rbp), %rsi
callq 0x22200
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xc0, %rdi
callq 0x21db0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21d80
testb $0x1, %al
jne 0x217dd
jmp 0x21853
leaq -0x20(%rbp), %rdi
callq 0x21de0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movl 0x4(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
cmpl $0x5, (%rax)
jne 0x2183a
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x4580
testb $0x1, %al
jne 0x2183a
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsi
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x4050
jmp 0x21851
movq -0x40(%rbp), %rax
testb $0x1, 0x54(%rax)
je 0x2184f
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x21851
jmp 0x21853
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::recvLoop()
bool MP2Node::recvLoop() {
	if ( memberNode->bFailed ) {
		return false;
	}
	else {
		return emulNet->ENrecv(&(memberNode->addr), this->enqueueWrapper, NULL, 1, &(memberNode->mp2q));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x50(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x21884
movb $0x0, -0x1(%rbp)
jmp 0x218c0
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movq 0x50(%rax), %rsi
addq $0x8, %rsi
movq 0x50(%rax), %r9
addq $0x98, %r9
leaq 0x2a(%rip), %rdx        # 0x218d0
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
callq 0xf240
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: Transaction::Transaction(MessageType, int)
Transaction::Transaction(MessageType _type, int timestamp) {
    this->successCount = 0;
    this->totalCount = 0;
    this->type = _type;
    this->txId = g_transID++;
    this->timestamp = timestamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x44b0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x44b0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x28013(%rip), %ecx     # 0x499b0
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x28008(%rip)     # 0x499b0
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string HashTable::read(string key) {
	map<string, string>::iterator search;

	search = hashTable.find(key);
	if ( search != hashTable.end() ) {
		// Value found
		return search->second;
	}
	else {
		// Value not found
		return "";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x26d90
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x26db0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x14f50
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14f20
testb $0x1, %al
jne 0x264e5
jmp 0x26500
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x4160
jmp 0x26545
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45c0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x5d8a(%rip), %rsi      # 0x2c2a6
callq 0x7790
jmp 0x26523
leaq -0x31(%rbp), %rdi
callq 0x43b0
jmp 0x26545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x43b0
jmp 0x2654f
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45b0
nopl (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool HashTable::update(string key, string newValue) {
	map<string, string>::iterator update;

	if (read(key).empty()) {
		// Key not found
		return false;
	}
	// Key found
	//update = hashTable.at(key) = newValue;
	hashTable.at(key) = newValue;
	// Update successful
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x26d90
movq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4160
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x26470
jmp 0x265c3
leaq -0x48(%rbp), %rdi
callq 0x4580
movb %al, -0x99(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x68(%rbp), %rdi
callq 0x4200
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x265f0
jmp 0x2660d
movb $0x0, -0x1(%rbp)
jmp 0x26637
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4200
jmp 0x26645
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x26de0
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x4050
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x45b0
nop
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::deleteKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool HashTable::deleteKey(string key) {
	uint eraseCount = 0;

	if (read(key).empty()) {
		// Key not found
		return false;
	}
	eraseCount = hashTable.erase(key);
	if ( eraseCount < 1 ) {
		// Could not erase
		return false;
	}
	// Delete was successful
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4160
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x26470
jmp 0x26699
leaq -0x40(%rbp), %rdi
callq 0x4580
movb %al, -0x89(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
leaq -0x60(%rbp), %rdi
callq 0x4200
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x266c6
jmp 0x266e3
movb $0x0, -0x1(%rbp)
jmp 0x2670a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4200
jmp 0x26718
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x26e80
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jae 0x26706
movb $0x0, -0x1(%rbp)
jmp 0x2670a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retPrimaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retPrimaryPairs() {
	vector<pair<string, string>> primaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
		Entry entry(it->second);
		if ( PRIMARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			primaryPairs.emplace_back(temp);
		}
	}
	return primaryPairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x26f30
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14ef0
movq %rax, -0x20(%rbp)
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14f50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14f20
testb $0x1, %al
jne 0x26846
jmp 0x2695b
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x4160
jmp 0x26864
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x288b0
jmp 0x26876
leaq -0x90(%rbp), %rdi
callq 0x4200
xorl %eax, %eax
cmpl -0x4c(%rbp), %eax
jne 0x26939
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
leaq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x26f50
jmp 0x268ab
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x26f90
jmp 0x268c0
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26981
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4200
jmp 0x26981
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26950
leaq -0x70(%rbp), %rdi
callq 0x22000
leaq -0x20(%rbp), %rdi
callq 0x14fa0
jmp 0x2681c
leaq -0x70(%rbp), %rdi
callq 0x22000
jmp 0x26981
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x26971
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0x98(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retSecondaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retSecondaryPairs() {
	vector<pair<string, string>> secondaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
			Entry entry(it->second);
			if ( SECONDARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			secondaryPairs.emplace_back(temp);
		}
	}
	return secondaryPairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x26f30
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14ef0
movq %rax, -0x20(%rbp)
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14f50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14f20
testb $0x1, %al
jne 0x26a16
jmp 0x26b2e
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x4160
jmp 0x26a34
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x288b0
jmp 0x26a46
leaq -0x90(%rbp), %rdi
callq 0x4200
movl $0x1, %eax
cmpl -0x4c(%rbp), %eax
jne 0x26b0c
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
leaq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x26f50
jmp 0x26a7e
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x26f90
jmp 0x26a93
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26b0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26b54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4200
jmp 0x26b54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26b23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26b23
leaq -0x70(%rbp), %rdi
callq 0x22000
leaq -0x20(%rbp), %rdi
callq 0x14fa0
jmp 0x269ec
leaq -0x70(%rbp), %rdi
callq 0x22000
jmp 0x26b54
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x26b44
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0x98(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retTertiaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retTertiaryPairs() {
	vector<pair<string, string>> tertiaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
			Entry entry(it->second);
			if ( TERTIARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			tertiaryPairs.emplace_back(temp);
		}
	}
	return tertiaryPairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x26f30
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14ef0
movq %rax, -0x20(%rbp)
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x14f50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14f20
testb $0x1, %al
jne 0x26be6
jmp 0x26cfe
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x4160
jmp 0x26c04
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x288b0
jmp 0x26c16
leaq -0x90(%rbp), %rdi
callq 0x4200
movl $0x2, %eax
cmpl -0x4c(%rbp), %eax
jne 0x26cdc
leaq -0x20(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
leaq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x26f50
jmp 0x26c4e
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x26f90
jmp 0x26c63
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4200
jmp 0x26d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x26cf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x27010
jmp 0x26cf3
leaq -0x70(%rbp), %rdi
callq 0x22000
leaq -0x20(%rbp), %rdi
callq 0x14fa0
jmp 0x26bbc
leaq -0x70(%rbp), %rdi
callq 0x22000
jmp 0x26d24
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x26d14
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x27040
movq -0x98(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x44b0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x44b0
movq -0x30(%rbp), %rdi
leaq 0x4467(%rip), %rsi      # 0x2ccc1
callq 0x44a0
jmp 0x28861
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x4050
jmp 0x28870
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x24(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x44b0
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x44b0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a475
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x78(%rbp)
callq 0x44b0
movq -0x78(%rbp), %rdi
leaq 0x282f(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x2a498
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x50(%rdi)
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a4b1
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x4050
jmp 0x2a4c9
movq -0x70(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x4050
jmp 0x2a4dc
movq -0x48(%rbp), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2a512
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x4200
movq -0x58(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x44b0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x44b0
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a575
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x40(%rbp)
callq 0x44b0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
callq 0x4050
jmp 0x2a599
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a5b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x4050
jmp 0x2a5c7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movb 0x54(%rax), %al
andb $0x1, %al
movb %al, 0x54(%rdi)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x50(%rdi)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x4050
jmp 0x2a606
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2a62f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4200
movq -0x30(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x4200
movq -0x18(%rbp), %rdi
callq 0x45b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %r9, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x44b0
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x44b0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a6b2
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x78(%rbp)
callq 0x44b0
movq -0x78(%rbp), %rdi
leaq 0x25f2(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x2a6d5
movq -0x70(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x50(%rdi)
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a6ee
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x4050
jmp 0x2a706
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x4050
jmp 0x2a719
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2a745
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x4200
movq -0x58(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x45b0
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %r8, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x44b0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x44b0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a7b7
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x68(%rbp)
callq 0x44b0
movq -0x68(%rbp), %rdi
leaq 0x24ed(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x2a7da
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x50(%rdi)
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a7f3
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x4050
jmp 0x2a80b
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2a834
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x4200
movq -0x30(%rbp), %rdi
callq 0x45b0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x44b0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x44b0
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a8a7
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x58(%rbp)
callq 0x44b0
movq -0x58(%rbp), %rdi
leaq 0x23fd(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x2a8ca
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x50(%rdi)
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a8e3
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x54(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2a91e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4200
movq -0x40(%rbp), %rdi
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x4200
movq -0x28(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x44b0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x44b0
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x71f0
jmp 0x2a994
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x60(%rbp)
callq 0x44b0
movq -0x60(%rbp), %rdi
leaq 0x2310(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x2a9b7
movq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x50(%rdi)
addq $0x48, %rdi
callq 0x18e70
jmp 0x2a9d0
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl $0x5, (%rdi)
addq $0x28, %rdi
callq 0x4050
jmp 0x2a9e9
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2aa12
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4200
movq -0x40(%rbp), %rdi
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x4200
movq -0x28(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
addq $0x58, %rdi
callq 0x4050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x18e70
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x4050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movb 0x54(%rax), %al
andb $0x1, %al
movb %al, 0x54(%rdi)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x50(%rdi)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x4050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x1d04(%rip), %rsi      # 0x2ccc1
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x80(%rbp)
callq 0x4640
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4370
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl $0xa, %edx
callq 0x28de0
movl %eax, -0x74(%rbp)
jmp 0x2b007
leaq -0x40(%rbp), %rdi
callq 0x4200
movl -0x74(%rbp), %eax
movq -0x90(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0xb8(%rbp)
callq 0x4240
movq -0x90(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0x18(%rbp), %rcx
notq %rcx
addq %rax, %rcx
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x4370
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x28de0
movl %eax, -0xa4(%rbp)
jmp 0x2b075
movl -0xa4(%rbp), %eax
movw %ax, -0xba(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4200
movw -0xba(%rbp), %cx
movq -0x98(%rbp), %rax
movw %cx, -0x4e(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movw -0x4e(%rbp), %cx
movw %cx, 0x4(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x2b0df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x45b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x438(%rbp)
movl $0xa, %esi
callq 0x2a70
jmp 0x238c
movq -0x438(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0x20e0
movl $0x0, -0x28(%rbp)
cmpl $0x2710, -0x28(%rbp)    # imm = 0x2710
jge 0x2406
movl $0x1, %edi
callq 0x20e0
leaq -0x430(%rbp), %rdi
callq 0x24b0
leaq -0x430(%rbp), %rsi
leaq 0x2c2f(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x2040
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23a8
movq -0x438(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2140
jmp 0x2414
jmp 0x2408
movl $0x1, %edi
callq 0x20e0
jmp 0x2408
movq -0x20(%rbp), %rdi
callq 0x2210
nopl (%rax)
// File: tiancihui[P]bo/./util/Common_Time.cpp
// Function: getTimeCurSec
unsigned long getTimeCurSec()
	{
		struct timeval tv;
		unsigned long  timeSe = 0;
		gettimeofday(&tv, NULL);
		timeSe = tv.tv_sec;
		return timeSe;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: tiancihui[P]bo/./util/Common_Time.cpp
// Function: getTimeCurUSec
unsigned long long  getTimeCurUSec()
	{
		struct timeval tv;
		unsigned long long timeUse = 0;
		gettimeofday(&tv, NULL);
		timeUse = tv.tv_sec;
		timeUse = timeUse*1000 + tv.tv_usec/1000;
		return timeUse;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2180
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x2190
movq -0x48(%rbp), %rcx
movq %rcx, %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x71(%rip), %rdx       # 0x2760
callq 0x2230
cmpl $0x0, %eax
je 0x27e9
leaq 0x2855(%rip), %rdi      # 0x5037
movb $0x0, %al
callq 0x2040
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x2918
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2160
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x294c
movq -0x10(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x21a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0x516a(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2540
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2540
jmp 0x2c3c
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x68, %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rsi
callq 0x2660
jmp 0x2c56
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0xa0, %rdi
movq %rdi, -0x50(%rbp)
addq $0x40, %rsi
callq 0x2660
jmp 0x2c73
movq -0x38(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3740
movq -0x38(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3740
movq -0x38(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x58(%rbp)
callq 0x3740
movq -0x38(%rbp), %rdi
addq $0xf0, %rdi
callq 0x3760
movq -0x38(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x3760
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2d8b
movl $0xb8, %edi
callq 0x2130
movq %rax, -0x70(%rbp)
jmp 0x2cf6
movq -0x38(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x4b80
jmp 0x2d05
movq -0x38(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x2de0
jmp 0x2d1c
movq -0x28(%rbp), %rdi
callq 0x2790
jmp 0x2d27
jmp 0x2d29
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2dc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2d91
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xb8, %esi
callq 0x2140
jmp 0x2d91
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3780
movq -0x60(%rbp), %rdi
callq 0x3780
movq -0x68(%rbp), %rdi
callq 0x3780
movq -0x50(%rbp), %rdi
callq 0x2690
movq -0x48(%rbp), %rdi
callq 0x2690
movq -0x30(%rbp), %rdi
callq 0x2560
movq -0x40(%rbp), %rdi
callq 0x2560
movq -0x18(%rbp), %rdi
callq 0x2210
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x40, %rdi
leaq 0x2306(%rip), %rsi      # 0x5109
movl $0x6d, %edx
callq 0x2590
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3a20
movq -0x18(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0x10(%rbp), %rsi
callq 0x3a20
movq -0x18(%rbp), %rdi
movl 0xc(%rdi), %eax
addl $0x1, %eax
movl %eax, 0xc(%rdi)
movl 0x10(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rdi)
addq $0x40, %rdi
leaq 0x22b3(%rip), %rsi      # 0x5109
movl $0x73, %edx
callq 0x25c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0xd8, %rdi
callq 0x37f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f7e
movq -0x20(%rbp), %rdi
addq $0xd8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3810
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f2b
movq -0x20(%rbp), %rdi
addq $0xd8, %rdi
callq 0x3760
movq -0x20(%rbp), %rdi
addq $0xf0, %rdi
callq 0x3760
movq -0x20(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x3760
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3015
jmp 0x3034
leaq 0x2080(%rip), %rdi      # 0x509c
leaq 0x2085(%rip), %rsi      # 0x50a8
movl $0x25, %edx
leaq 0x2091(%rip), %rcx      # 0x50c0
callq 0x20c0
movq -0x28(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0x304d
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x26b0
movq -0x28(%rbp), %rdi
callq 0x30b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30a5
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
leaq 0x2082(%rip), %rsi      # 0x50f2
movl $0x2e, %edx
callq 0x2590
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4db0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x40, %rdi
leaq 0x204d(%rip), %rsi      # 0x511c
movl $0x78, %edx
callq 0x2590
movq -0x20(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x37f0
cmpq $0x0, %rax
jne 0x3101
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
callq 0x26b0
jmp 0x30d9
movq -0x20(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x37f0
cmpq $0x0, %rax
jbe 0x3151
movq -0x20(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x3830
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rdi
leaq 0x1fdf(%rip), %rsi      # 0x511c
movl $0x7f, %edx
callq 0x25c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3172
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1fbc(%rip), %rsi      # 0x511c
movl $0x83, %edx
callq 0x25c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)