LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::remove_counts_for_new_document(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
void HMMLDA::remove_counts_for_new_document(vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment, vector<int> &num_words_in_document_assigned_to_topic, int doc_size) {
	int previous_class = -1;
	for(int word_idx = 0; word_idx < doc_size; word_idx++) {
		int word = document[word_idx];
		if(class_assignment[word_idx] == 0) {		// Count the topic only when the class is 0
			num_words_in_document_assigned_to_topic[topic_assignment[word_idx]]--;
			num_same_words_assigned_to_topic[word][topic_assignment[word_idx]]--;
			num_words_assigned_to_topic[topic_assignment[word_idx]]--;
		}
		num_same_words_assigned_to_class[word][class_assignment[word_idx]]--;
		num_words_assigned_to_class[class_assignment[word_idx]]--;
		int current_class = class_assignment[word_idx];
		if(previous_class != -1)
			num_transitions[previous_class][current_class]--;
		previous_class = current_class;
	}
}

// Assembly:
testl %r9d, %r9d
jle 0x49d0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %rax
movq (%rcx), %rcx
movq (%rdx), %rdx
movq (%r8), %rsi
movq %rsi, -0x30(%rbp)
movq 0x108(%rdi), %r8
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %r11
movq 0x168(%rdi), %rbx
movq 0x138(%rdi), %rdi
movl %r9d, %r9d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movslq (%rax,%r14,4), %r12
cmpl $0x0, (%rcx,%r14,4)
leaq (%r12,%r12,2), %r12
jne 0x498c
movslq (%rdx,%r14,4), %r13
movq -0x30(%rbp), %rsi
decl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %r13
movq (%r8,%r12,8), %rsi
decl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %rsi
decl (%r11,%rsi,4)
movslq (%rcx,%r14,4), %rsi
movq (%r10,%r12,8), %r12
decl (%r12,%rsi,4)
movslq (%rcx,%r14,4), %rsi
decl (%rbx,%rsi,4)
movl (%rcx,%r14,4), %r12d
cmpl $-0x1, %r15d
je 0x49bb
movslq %r12d, %rsi
movslq %r15d, %r15
leaq (%r15,%r15,2), %r15
movq (%rdi,%r15,8), %r15
decl (%r15,%rsi,4)
incq %r14
movl %r12d, %r15d
cmpq %r14, %r9
jne 0x495d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::input_to_document(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int HMMLDA::input_to_document(vector<string> &words, vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment) {
	for(int i = 0; i < (int)words.size(); i++) {
		document[i] = vocab_dict[words[i]];
		topic_assignment[i] = topic_dist(rng);
		if(document[i] == start_word_id)
			class_assignment[i] = START_WORD_CLASS;
		else if(document[i] ==  end_word_id)
			class_assignment[i] = END_WORD_CLASS;
		else
			class_assignment[i] = class_dist(rng);
	}
	return words.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x60(%rbp)
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq (%rsi), %rsi
movq %rax, -0x48(%rbp)
movq 0x8(%rax), %rax
subq %rsi, %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x4acd
movq %rdi, %r13
leaq 0x70(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x1508(%rdi), %r14
leaq 0x180(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x1510(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movq -0x50(%rbp), %r12
addq %rbx, %rsi
movq -0x40(%rbp), %rdi
callq 0x5b88
movl (%rax), %eax
movq (%r12), %rcx
movl %eax, (%rcx,%r15,4)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0x6c3e
movq -0x58(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
movq (%r12), %rax
movl (%rax,%r15,4), %eax
cmpl 0x8(%r13), %eax
jne 0x4a81
movl 0x10(%r13), %eax
jmp 0x4a9d
cmpl 0xc(%r13), %eax
jne 0x4a8d
movl 0x14(%r13), %eax
jmp 0x4a9d
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rdi, %rdx
callq 0x6c3e
movq -0x60(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
shrq $0x5, %rax
movslq %eax, %rcx
addq $0x20, %rbx
cmpq %rcx, %r15
jl 0x4a3d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: void split<std::back_insert_iterator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::back_insert_iterator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
void split(const std::string &s, char delim, Out result) {
	std::stringstream ss;
	ss.str(s);
	std::string item;
	while (std::getline(ss, item, delim)) {
		*(result++) = item;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq -0x1d0(%rbp), %rdi
callq 0x2170
leaq -0x1b8(%rbp), %rdi
movq %r15, %rsi
callq 0x22f0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x23b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5fde
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5b3c
jmp 0x5fb5
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5fec
callq 0x2210
movq 0x4fc5(%rip), %rsi      # 0xafb8
leaq -0x1d0(%rbp), %rdi
callq 0x21a0
leaq -0x150(%rbp), %rdi
callq 0x20b0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6035
jmp 0x6024
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6035
callq 0x2210
movq 0x4f7c(%rip), %rsi      # 0xafb8
leaq -0x1d0(%rbp), %rdi
callq 0x21a0
leaq -0x150(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/wdebug.cc
// Function: print(int const*, unsigned long)
void print(const int ia[], size_t size)
{
#ifndef NDEBUG
// __func__ is a local static defined by the compiler that holds the name of this function
cerr << __func__ << ": array size is " << size << endl;
#endif
// . . .
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x2d83(%rip), %r14      # 0x3ff0
leaq 0xd90(%rip), %rsi       # 0x2004
movl $0x5, %edx
movq %r14, %rdi
callq 0x10c0
leaq 0xd82(%rip), %rsi       # 0x200a
movl $0x10, %edx
movq %r14, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/main.cpp
// Function: printToTextFile(Board)
void printToTextFile(Board gameboard) //Prints the game board to a text file
{
	std::ofstream out_data("Levels/level.txt");
	out_data << "Level:" << std::endl;
	for (auto& inner : gameboard.m_board)
	{
		for (auto& item : inner)
		{
			if (item != NULL)
				out_data << item->getRotations() << item->getType();
			else
				out_data << '0' << '.';

		}
		out_data << std::endl;
	}
	out_data.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %r14
leaq 0x14596(%rip), %rsi     # 0x18020
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x3250
leaq 0x1458c(%rip), %rsi     # 0x18031
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3280
movq -0x238(%rbp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0x3b9e
leaq -0x29(%rbp), %r14
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0x3b65
movq (%r13), %rax
testq %rax, %rax
je 0x3b37
movl (%rax), %esi
movq %rbx, %rdi
callq 0x33c0
movq (%r13), %rcx
movb 0x8(%rcx), %cl
movb %cl, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
jmp 0x3b5f
movb $0x30, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movb $0x2e, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
addq $0x8, %r13
jmp 0x3b03
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0x18, %r15
cmpq -0x38(%rbp), %r15
jne 0x3afc
leaq -0x238(%rbp), %rdi
callq 0x32f0
movq 0x1b407(%rip), %rax     # 0x1efb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x31e0
leaq -0x140(%rbp), %rdi
callq 0x30d0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bf6
jmp 0x3bf6
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/main.cpp
// Function: printStack(TileStack)
void printStack(TileStack stack) //debugging
{
	/*print tile stack content for debugging*/
	std::cout << "TileStack content(" << stack.tiles.size() << "): ";
	for(int i = 0; i < stack.tiles.size(); i++) {
		Tile tile = stack.tiles[i];
		std::cout << tile.getType() << ' ';
	}
	std::cout << std::endl;/**/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r14
movq 0x1b115(%rip), %rbx     # 0x1efc8
leaq 0x141b9(%rip), %rsi     # 0x18073
movl $0x12, %edx
movq %rbx, %rdi
callq 0x3280
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movabsq $0x34f72c234f72c235, %rax # imm = 0x34F72C234F72C235
imulq %rax, %rsi
movq %rbx, %rdi
callq 0x3170
leaq 0x14197(%rip), %rsi     # 0x18086
movl $0x3, %edx
movq %rax, %rdi
callq 0x3280
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x3f84
xorl %ebx, %ebx
leaq -0x118(%rbp), %r15
leaq -0x29(%rbp), %r13
xorl %r12d, %r12d
addq %rbx, %rsi
movq %r15, %rdi
callq 0x8b34
movb -0x110(%rbp), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq 0x1b093(%rip), %rdi     # 0x1efc8
movq %r13, %rsi
callq 0x3280
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x3280
movq %r15, %rdi
callq 0x16aa0
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x34f72c234f72c235, %rcx # imm = 0x34F72C234F72C235
imulq %rcx, %rax
addq $0xe8, %rbx
cmpq %r12, %rax
ja 0x3f15
movq 0x1b03d(%rip), %rbx     # 0x1efc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x16aa0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/main.cpp
// Function: parseMessageList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string parseMessageList(std::string &msg) //finds and returns the first message in the message list
{
	std::string token;
	std::string delimiter = "\r\n";
	size_t pos = 0;

	pos = msg.find(delimiter);
	token = msg.substr(0, pos);
	msg.erase(0, pos + delimiter.length());

	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1477f(%rip), %rsi     # 0x18793
leaq 0x1477a(%rip), %rdx     # 0x18795
leaq -0x48(%rbp), %rdi
callq 0x9e42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
movq %rax, %r15
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3240
leaq -0x68(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32b0
movq (%r12), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x406b
callq 0x3200
addq -0x40(%rbp), %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3070
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x408e
callq 0x3200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40a2
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x40bc
callq 0x3200
jmp 0x40bc
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x40c9
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/main.cpp
// Function: getMesssage(Client&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string getMesssage(Client &client, std::string &msg_list) //Updates the message list and then parses for the first message to return.
{
	std::string msg;
	if (msg_list.empty())
	{
		msg_list = client.receiveMessage();
		//msg_list = "NEW CHALLENGE 1 YOU WILL PLAY 1 MATCH\r\nBEGIN ROUND 1 OF 1\r\nYOUR OPPONENT IS PLAYER Blue";
		msg = parseMessageList(msg_list);
	}
	else msg = parseMessageList(msg_list);
	/*#ifdef DEBUG
		std::cout << "Message got: " << msg << std::endl;
	#endif*/

	return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rdx)
je 0x413c
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3fdb
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x412c
callq 0x3200
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xf468
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
movq (%r15), %rdi
leaq -0x30(%rbp), %r15
cmpq %r15, %rdi
je 0x4165
callq 0x3200
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3fdb
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
movq (%r14), %rdi
cmpq %r15, %rdi
jne 0x4127
jmp 0x412c
jmp 0x418e
jmp 0x418e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x419e
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::numRotations(int)
int Adapter::numRotations(const int x) {
	int numRotations = 0;
	if (x == 90)
		return numRotations = 1;
	if (x == 180)
		return numRotations = 2;
	if (x == 270)
		return numRotations = 3;

	return numRotations;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x5a, %esi
je 0xa97d
cmpl $0x10e, %esi            # imm = 0x10E
je 0xa976
cmpl $0xb4, %esi
jne 0xa984
movl $0x2, %eax
jmp 0xa986
movl $0x3, %eax
jmp 0xa986
movl $0x1, %eax
jmp 0xa986
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::convertExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string> Adapter::convertExpression(const std::string& expr) {
	// Convert to stream
	std::istringstream buf(expr);
	std::istream_iterator<std::string> begin(buf), end;

	// Store in vector and return
	std::vector<std::string> myV(begin, end);
	return myV;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq -0x268(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x33b0
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0xc716
xorl %eax, %eax
leaq -0x40(%rbp), %r14
movq %rax, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movb %al, 0x10(%r14)
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0xa0(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rdx
addq %rsi, %rdx
callq 0x9da8
movb -0x60(%rbp), %al
movb %al, -0x90(%rbp)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0xd0(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
callq 0x9da8
movb -0x30(%rbp), %al
leaq -0xe8(%rbp), %rdx
movb %al, 0x28(%rdx)
leaq -0xb8(%rbp), %rsi
leaq -0x21(%rbp), %rcx
movq %rbx, %rdi
callq 0xc768
movq -0xe0(%rbp), %rdi
cmpq %r12, %rdi
je 0xaa6e
callq 0x3200
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa7f
callq 0x3200
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa8d
callq 0x3200
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa9f
callq 0x3200
movq 0x1451a(%rip), %rsi     # 0x1efc0
leaq -0x268(%rbp), %rdi
callq 0x3300
leaq -0x1f0(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xe0(%rbp), %rdi
cmpq %r12, %rdi
je 0xaaea
callq 0x3200
jmp 0xaaea
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0xab00
callq 0x3200
jmp 0xab00
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xab0e
callq 0x3200
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xab25
callq 0x3200
jmp 0xab25
movq %rax, %rbx
movq 0x14494(%rip), %rsi     # 0x1efc0
leaq -0x268(%rbp), %rdi
callq 0x3300
leaq -0x1f0(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Adapter::get(const std::string& prop) {
	if (prop == "pid")
		return this->playerID;
	if (prop == "rid")
		return this->roundID;
	if (prop == "score")
		return this->score;
	if (prop == "challenges")
		return this->numChallenges;
	if (prop == "rounds")
		return this->numRounds;
	if (prop == "ptime")
		return this->planTime;
	if (prop == "mtime")
		return this->moveTime;

	return "Error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd9eb(%rip), %rsi      # 0x18551
movq %rdx, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac22
leaq 0xd9d8(%rip), %rsi      # 0x18555
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac32
leaq 0xd9c5(%rip), %rsi      # 0x18559
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac43
leaq 0xd9b4(%rip), %rsi      # 0x1855f
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac54
leaq 0xd9a8(%rip), %rsi      # 0x1856a
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac65
leaq 0xd998(%rip), %rsi      # 0x18571
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac7c
leaq 0xd987(%rip), %rsi      # 0x18577
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xac93
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xd96f(%rip), %rsi      # 0x1857d
leaq 0xd96d(%rip), %rdx      # 0x18582
movq %rbx, %rdi
callq 0x9e42
jmp 0xacb3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
jmp 0xaca8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0xc0(%r14), %rsi
movq 0xc8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9da8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Adapter::set(const std::string& prop, const std::string value) {
	if (prop == "pid")
		this->playerID = value;
	if (prop == "rid")
		this->roundID = value;
	if (prop == "score")
		this->score = value;
	if (prop == "challenges")
		this->numChallenges = value;
	if (prop == "rounds")
		this->numRounds = value;
	if (prop == "ptime")
		this->planTime = value;
	if (prop == "mtime")
		this->moveTime = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xd875(%rip), %rsi      # 0x18551
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xacf3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd85b(%rip), %rsi      # 0x18555
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xad12
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd840(%rip), %rsi      # 0x18559
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xad31
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd827(%rip), %rsi      # 0x1855f
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xad50
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd813(%rip), %rsi      # 0x1856a
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xad72
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd7f8(%rip), %rsi      # 0x18571
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xad94
leaq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd7dc(%rip), %rsi      # 0x18577
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xadb2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::getTileString[abi:cxx11](int const&)
std::string Adapter::getTileString(const int& index) {
	// Error check
	if (index < 0 || index > this->tileList.size())
		return "Error";

	return this->tileList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
testq %rax, %rax
js 0xadf9
movq 0xe0(%rsi), %rcx
movq 0xe8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rax, %rdx
jae 0xae18
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xd776(%rip), %rsi      # 0x1857d
leaq 0xd774(%rip), %rdx      # 0x18582
movq %rbx, %rdi
callq 0x9e42
jmp 0xae37
shlq $0x5, %rax
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9da8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::convertZone(std::pair<int, int>)
int Adapter::convertZone(std::pair<int, int> location)
{
	int i = location.first;
	int j = location.second;

	if(i == 0)
	{
		if(j == 0) return 1;
		else if(j == 1) return 2;
		else if(j == 2) return 3;
	}
	else if(i == 1)
	{
		if(j == 0) return 4;
		else if(j == 1) return 5;
		else if(j == 2) return 6;
	}
	else if(i == 2)
	{
		if(j == 0) return 7;
		else if(j == 1) return 8;
		else if(j == 2) return 9;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
shrq $0x20, %rcx
cmpl $0x1, %esi
je 0xaea9
testl %esi, %esi
jne 0xaec0
movl $0x1, %eax
testq %rcx, %rcx
je 0xaed5
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
xorl $0x3, %eax
jmp 0xaed5
movl $0x4, %eax
testq %rcx, %rcx
je 0xaed5
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
addl $0x5, %eax
jmp 0xaed5
movl $0x7, %eax
testq %rcx, %rcx
je 0xaed5
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
xorl $0x9, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Game.cpp
// Function: Game::Game(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Player, Player, TileStack, Tile, std::pair<int, int>)
Game::Game(std::string gameId, Player p1, Player p2, TileStack t, Tile startingTile, std::pair<int,int> startingCoordinates)
{
	Tile *startTile = new Tile(startingTile.getNum());
	gameboard.place_tile(startingCoordinates, *startTile);

	numMeeples = 7;
	player1 = p1;
	player2 = p2;
	this->gameId = gameId;
	tileStack = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, -0x58(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, -0x60(%rbp)
movq %rdi, %rbx
callq 0xf52c
leaq 0x20(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x30(%rbx), %rax
movq %rax, -0x50(%rbp)
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movq %rdi, -0x48(%rbp)
callq 0x14e70
leaq 0x60(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0x14e70
leaq 0x80(%rbx), %rdi
movq %rdi, -0x30(%rbp)
callq 0x14f0c
movl $0xe8, %edi
callq 0x3220
movq %rax, %r14
movl 0x4(%r12), %esi
movq %rax, %rdi
callq 0x158a8
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x112c4
movl $0x7, 0x18(%rbx)
movq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0xec68
movl 0x18(%r15), %eax
movl %eax, 0x58(%rbx)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0xec68
movl 0x18(%r13), %eax
movl %eax, 0x78(%rbx)
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3140
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x9644
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x3200
jmp 0xce0e
movq %rax, %r15
jmp 0xce17
movq %rax, %r15
jmp 0xce20
movq %rax, %r15
jmp 0xce29
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0x151ae
movq -0x38(%rbp), %rdi
callq 0x14e84
movq -0x48(%rbp), %rdi
callq 0x14e84
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xce3b
callq 0x3200
movq %rbx, %rdi
callq 0xf5f2
movq %r15, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Game.cpp
// Function: Game::printToTextFile(Board)
void Game::printToTextFile(Board gameboard)
{
	std::ofstream out_data("Levels/level.txt");
	out_data << "Level:" << std::endl;
	for (auto& inner : gameboard.m_board)
	{
		for (auto& item : inner)
		{
			if (item != NULL)
				out_data << item->getRotations() << item->getType();
			else
				out_data << '0' << '.';

		}
		out_data << std::endl;
	}
	out_data.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
leaq 0xabb4(%rip), %rsi      # 0x18020
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x3250
leaq 0xabaa(%rip), %rsi      # 0x18031
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3280
movq -0x238(%rbp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0xd580
leaq -0x29(%rbp), %r14
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0xd547
movq (%r13), %rax
testq %rax, %rax
je 0xd519
movl (%rax), %esi
movq %rbx, %rdi
callq 0x33c0
movq (%r13), %rcx
movb 0x8(%rcx), %cl
movb %cl, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
jmp 0xd541
movb $0x30, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movb $0x2e, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
addq $0x8, %r13
jmp 0xd4e5
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0x18, %r15
cmpq -0x38(%rbp), %r15
jne 0xd4de
leaq -0x238(%rbp), %rdi
callq 0x32f0
movq 0x11a25(%rip), %rax     # 0x1efb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x31e0
leaq -0x140(%rbp), %rdi
callq 0x30d0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd5d8
jmp 0xd5d8
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Game.cpp
// Function: Game::enemyMove(Tile, int, int, int, bool, bool, std::pair<int, int>)
void Game::enemyMove(Tile tile, int i, int j, int orientation, bool tiger, bool croc, std::pair<int,int> tigerSpot)
{
	//create a tile to place
  Tile *tmpTile = new Tile(tile.getNum());
  //set the proper orientation for the tile
  for(int k = 0; k< orientation; k++)
  {
    tmpTile->rotate();
  }
	std::pair<int, int> optimalLocation(i,j);
	//place the tile at the location specified 
  gameboard.place_tile(optimalLocation, *tmpTile);
  // if there is a tiger place it 
  if(tiger) gameboard.placeMeeple(i, j, tigerSpot);
  // if there is a croc place it
  if(croc) gameboard.placeCroc(i ,j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, %r13d
movq %rcx, -0x40(%rbp)
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x10(%rbp), %al
movb %al, -0x29(%rbp)
movl $0xe8, %edi
callq 0x3220
movq %rax, %r12
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x158a8
testl %r13d, %r13d
jle 0xd64d
movq %r12, %rdi
callq 0x16ae6
decl %r13d
jne 0xd640
movq -0x40(%rbp), %rbx
movq %rbx, %rax
shlq $0x20, %rax
movl %r14d, %esi
orq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x112c4
cmpb $0x0, -0x30(%rbp)
je 0xd680
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x38(%rbp), %rcx
callq 0x11d0c
cmpb $0x0, -0x29(%rbp)
je 0xd6a1
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x112a4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x3200
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Network.cpp
// Function: Client::Client(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Client::Client(std::string hostname, std::string port)
{
    portno = stoi(port);
    server = gethostbyname(hostname.c_str());
    if (server == NULL) {
        fprintf(stderr,"ERROR, no such host\n");
        exit(0);
    }
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        error("ERROR opening socket");
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
    serv_addr.sin_port = htons(portno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
callq 0x3040
movq %rax, %r14
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x32e0
cmpq %r12, (%r13)
je 0xf374
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xf380
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0xf380
testl %ecx, %ecx
jne 0xf302
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
movl %eax, 0x4(%rbx)
movq (%r15), %rdi
callq 0x3270
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xf38c
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3080
movl %eax, (%rbx)
testl %eax, %eax
js 0xf391
leaq 0xc(%rbx), %rdi
movl $0x10, %esi
callq 0x33d0
movw $0x2, 0xc(%rbx)
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x10(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x3390
movzwl 0x4(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0xe(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ff5(%rip), %rdi      # 0x18370
callq 0x3150
leaq 0x8fe9(%rip), %rdi      # 0x18370
callq 0x3320
callq 0x35e0
callq 0x35c9
cmpl $0x0, (%r14)
jne 0xf3a2
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
movq %rax, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Network.cpp
// Function: Client::connectToServer()
void Client::connectToServer()
{
  int tmp = connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
  if (tmp < 0)
      error("ERROR connecting");
  else
      fprintf(stdout, "Connected to Server successfully!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
leaq 0xc(%rdi), %rsi
movl %eax, %edi
movl $0x10, %edx
callq 0x31c0
testl %eax, %eax
js 0xf3ff
movq 0xfbbb(%rip), %rax      # 0x1efa0
movq (%rax), %rcx
leaq 0x9409(%rip), %rdi      # 0x187f8
movl $0x22, %esi
movl $0x1, %edx
popq %rbp
jmp 0x3430
callq 0x3607
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Network.cpp
// Function: Client::sendMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::sendMessage(std::string message)
{
  bzero(buffer,1000);
  message.copy(buffer, 999, 0);
  //fgets(buffer,255,stdin);
  n = write(sockfd,buffer,strlen(buffer));
  if (n < 0){
    error("ERROR writing to socket");
  }
  //#ifdef DEBUG
  //std::cout << "Message sent: " << message << std::endl;
  //#endif

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movl $0x3e8, %esi            # imm = 0x3E8
movq %r15, %rdi
callq 0x33d0
movl $0x3e7, %edx            # imm = 0x3E7
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x3060
movl (%rbx), %r14d
movq %r15, %rdi
callq 0x3110
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x30e0
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0xf462
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x361e
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Network.cpp
// Function: Client::receiveMessage[abi:cxx11]()
std::string Client::receiveMessage()
{
  std::string message;
  bzero(buffer,1000);
  n = read(sockfd,buffer,999);
  if (n < 0){
    error("ERROR reading from socket");
  }
  else{
    message = buffer;
  }
  return message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsi), %r14
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdi
callq 0x33d0
movl (%r15), %edi
movl $0x3e7, %edx            # imm = 0x3E7
movq %r14, %rsi
callq 0x3310
movl %eax, 0x8(%r15)
testl %eax, %eax
js 0xf4e0
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x3370
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3635
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xf4f5
callq 0x3200
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::Board()
Board::Board()
{
	// Initialize board to be 150x150 vector of null Tiles*
	Tile *NULL_tile = NULL;
	for(int i = 0; i < 160; i++)
	{
		std::vector<Tile*> temp;
		m_board.push_back(temp);
		for(int j = 0; j < 160; j++) {
			m_board[i].push_back(NULL_tile);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
leaq -0x30(%rbp), %r14
movq %r12, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x1409e
movl $0xa0, %r13d
leaq (%r12,%r12,2), %r15
movq (%rbx), %rax
leaq (%rax,%r15,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf598
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0xf5a0
movq %r14, %rdx
callq 0x143c4
decl %r13d
jne 0xf579
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xf5b3
callq 0x3200
incq %r12
cmpq $0xa0, %r12
jne 0xf554
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf5d0
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xf5e1
callq 0x3200
movq %rbx, %rdi
callq 0x140da
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::animalPoints(int, int)
int Board::animalPoints(int i, int j)
{
	const int DEN_POINTS = 10;
	const int DEER_POINTS = 2;
	const int BOAR_POINTS = 2;
	const int BUFFALO_POINTS = 2;
	const int CROCODILE_POINTS = -2;
	int points = 0;
	// You'll check the tile for existence of animal/dens listed above and add points accordingly if present
	if (m_board[i][j]->getCenter().getType() == "Den")
	{
		points += DEN_POINTS;
	}
	if (m_board[i][j]->hasBoar())
	{
		points += BOAR_POINTS;
	}
	if (m_board[i][j]->hasBuffalo())
	{
		points += BUFFALO_POINTS;
	}
	if (m_board[i][j]->hasDeer())
	{
		points += DEER_POINTS;
	}
	if (m_board[i][j]->hasCrocodile())
	{
		points += CROCODILE_POINTS;
	}
	return points;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movslq %esi, %rax
movq (%rdi), %rcx
leaq (%rax,%rax,2), %r13
movslq %edx, %r12
movq (%rcx,%r13,8), %rax
movq (%rax,%r12,8), %rax
movq 0xd0(%rax), %rax
movq 0x18(%rax), %rax
movzwl 0x28(%rax), %ecx
leaq -0x68(%rbp), %rdi
movw %cx, -0x8(%rdi)
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
callq 0x9da8
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x10(%r14), %rsi
movq -0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x9da8
leaq 0x7679(%rip), %rsi      # 0x18890
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x30b0
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x11237
callq 0x3200
leaq -0x70(%rbp), %rdi
callq 0x17912
xorl %eax, %eax
testl %r14d, %r14d
movl $0xa, %ecx
cmovnel %eax, %ecx
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rax
cmpb $0x0, 0x9(%rax)
leal 0x2(%rcx), %edx
cmovel %ecx, %edx
leal 0x2(%rdx), %ecx
cmpb $0x0, 0xa(%rax)
cmovel %edx, %ecx
leal 0x2(%rcx), %edx
cmpb $0x0, 0xb(%rax)
cmovel %ecx, %edx
cmpb $0x0, 0xc(%rax)
leal -0x2(%rdx), %eax
cmovel %edx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x17912
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::place_tile(std::pair<int, int>, Tile&)
void Board::place_tile(std::pair<int, int> location, Tile &tile)
{
	int row = location.first;
	int col = location.second;

	m_board[row][col] = &tile;
	connectFaces(row, col);
	std::vector<Structure> availableStructures = getStructures(row, col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, %r14
shrq $0x20, %r14
movslq %esi, %r15
movq (%rdi), %rax
leaq (%r15,%r15,2), %rcx
sarq $0x20, %rsi
movq (%rax,%rcx,8), %rax
movq %rdx, (%rax,%rsi,8)
movl %r15d, %esi
movl %r14d, %edx
callq 0x11328
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x11974
movq %r12, %rdi
callq 0xec22
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkJungle(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkJungle(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure jungleStruct("jungle", blockSpot);
	jungleStruct.checkAnimals(tile);
	// Keep track of visited tiles so we don't double count for animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue the BFS from the jungle's neighbors
	buildJungle(&jungleStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return jungleStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x58(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x6a4c(%rip), %rsi      # 0x187ab
leaq 0x6a4b(%rip), %rdx      # 0x187b1
leaq -0x78(%rbp), %r13
movq %r13, %rdi
callq 0x9e42
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x179d0
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x11d8e
callq 0x3200
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x17b04
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
testq %rsi, %rsi
je 0x11dc0
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x11dcd
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x143c4
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rcx
movq %r14, %r8
callq 0x11e40
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x11df5
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x11e30
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x11e38
callq 0x3200
jmp 0x11e38
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x11e30
callq 0x3200
movq %rbx, %rdi
callq 0x17ad8
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkLake(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkLake(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure lakeStruct("lake", blockSpot);
	lakeStruct.checkAnimals(tile);
	// Keep track of visited tiles so we don't double count for animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue the BFS
	buildLake(&lakeStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return lakeStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x58(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5a8d(%rip), %rsi      # 0x187b2
leaq 0x5a8a(%rip), %rdx      # 0x187b6
leaq -0x78(%rbp), %r13
movq %r13, %rdi
callq 0x9e42
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x179d0
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x12d54
callq 0x3200
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x17b04
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
testq %rsi, %rsi
je 0x12d86
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x12d93
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x143c4
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rcx
movq %r14, %r8
callq 0x12e06
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x12dbb
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x12df6
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x12dfe
callq 0x3200
jmp 0x12dfe
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x12df6
callq 0x3200
movq %rbx, %rdi
callq 0x17ad8
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkTrail(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkTrail(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure trailStruct("trail", blockSpot);
	trailStruct.checkAnimals(tile);
	// Keep track of visited tiles in order to not double count a tile's animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue constructing the trail with our defined logic
	buildTrail(&trailStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return trailStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x58(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x51b2(%rip), %rsi      # 0x187b7
leaq 0x51b0(%rip), %rdx      # 0x187bc
leaq -0x78(%rbp), %r13
movq %r13, %rdi
callq 0x9e42
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x179d0
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x13634
callq 0x3200
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x17b04
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
testq %rsi, %rsi
je 0x13666
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x13673
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x143c4
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rcx
movq %r14, %r8
callq 0x136e6
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1369b
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x136d6
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x136de
callq 0x3200
jmp 0x136de
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x136d6
callq 0x3200
movq %rbx, %rdi
callq 0x17ad8
movq %r14, %rdi
callq 0x33f0