LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::train(int, int)
void HMMLDA::train(int iterations, int save_freq) {
	save_assignments(0);
	// Run Gibbs sampling
	// iterations = number of full samplings of the corpus
	int n_documents = documents.size();
	for(int i = 1; i <= iterations; i++) {
		std::clock_t start = std::clock();
		for(int document_idx = 0; document_idx < n_documents; document_idx++) {
			int doc_size = documents[document_idx].size();
			for(int word_idx = 0; word_idx < doc_size; word_idx++) {
				draw_class(document_idx, word_idx, doc_size);
				draw_topic(document_idx, word_idx, doc_size);
			}
		}
		std::cout << "Time for iteration " << i <<": " << (std::clock() - start) / (double)(CLOCKS_PER_SEC) << " s" << endl;
		if((i%save_freq) == 0)
			save_assignments(i);
		// cout << endl << endl << endl << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x4eb0
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
callq 0x8be0
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x4ea3
callq 0x3180
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4e09
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x24(%rbp), %rsi
callq 0x8c10
movq %rax, %rdi
callq 0x8e50
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x4dfc
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x5530
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x63e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4dc5
jmp 0x4dfe
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4d97
movq 0x151c8(%rip), %rdi     # 0x19fd8
leaq 0xd28e(%rip), %rsi      # 0x120a5
callq 0x3240
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x33f0
movq %rax, %rdi
leaq 0xd251(%rip), %rsi      # 0x12082
callq 0x3240
movq %rax, -0x40(%rbp)
callq 0x3180
movq -0x40(%rbp), %rdi
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xd1bc(%rip), %xmm1     # 0x12010
divsd %xmm1, %xmm0
callq 0x3430
movq %rax, %rdi
leaq 0xd252(%rip), %rsi      # 0x120b9
callq 0x3240
movq %rax, %rdi
movq 0x15152(%rip), %rsi     # 0x19fc8
callq 0x3270
movl -0x18(%rbp), %eax
cltd
idivl -0x10(%rbp)
cmpl $0x0, %edx
jne 0x4e93
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4eb0
jmp 0x4e95
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4d7b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8dc0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x6ea0
movq -0x38(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8cc0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x8ce0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, (%rax)
movq %rsi, %rdi
addq $0x1508, %rdi           # imm = 0x1508
addq $0x180, %rsi            # imm = 0x180
callq 0x8f30
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movq -0x38(%rbp), %rcx
movl (%rax), %eax
cmpl 0x8(%rcx), %eax
jne 0x6e29
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movl -0x54(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x6e90
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movq -0x38(%rbp), %rcx
movl (%rax), %eax
cmpl 0xc(%rcx), %eax
jne 0x6e5f
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movl -0x58(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x6e8e
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x1510, %rdi           # imm = 0x1510
addq $0x180, %rsi            # imm = 0x180
callq 0x8f30
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8f60
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x6e90
jmp 0x6e92
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6d6b
movq -0x10(%rbp), %rdi
callq 0x8dc0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x200, %rsp            # imm = 0x200
movb %sil, %al
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x31b0
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x32a0
jmp 0x989e
leaq -0x1d0(%rbp), %rdi
callq 0x3300
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3420
movq %rax, -0x1e8(%rbp)
jmp 0x98ca
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32d0
movb %al, -0x1e9(%rbp)
jmp 0x98e8
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x98f7
jmp 0x997c
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x114b0
movq %rax, -0x1f8(%rbp)
jmp 0x990b
movq -0x1f8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x114d0
movq %rax, -0x200(%rbp)
jmp 0x992e
movq -0x200(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x114e0
jmp 0x9943
jmp 0x98aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x999d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3160
jmp 0x999d
leaq -0x1d0(%rbp), %rdi
callq 0x3160
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movq -0x1a8(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
nop
// File: abaheti95[P]HMM-LDA/cpp_hmm_lda_trainer.cpp
// Function: load_documents_to_model(HMMLDA&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void load_documents_to_model(HMMLDA &model, string &documents_filename) {
	ifstream file(documents_filename, ios::in);
	string str;
	int counter = 0;
	while(getline(file, str)) {
		stringstream ss(str);
		int num;
		vector<int> document;
		while(ss >> num) {
			document.push_back(num);
		}
		model.add_document(document);
		counter ++;
		// if(counter == 10000) break;
		if(counter%1000000 == 0) {
			cout << counter << endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x33a0
leaq -0x238(%rbp), %rdi
callq 0x3300
movl $0x0, -0x23c(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3070
movq %rax, -0x418(%rbp)
jmp 0x1156a
movq -0x418(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32d0
movb %al, -0x419(%rbp)
jmp 0x11588
movb -0x419(%rbp), %al
testb $0x1, %al
jne 0x11597
jmp 0x1174c
movl $0x10, %edi
movl $0x8, %esi
callq 0x8f80
movl %eax, -0x420(%rbp)
jmp 0x115ae
movl -0x420(%rbp), %edx
leaq -0x3d8(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3370
jmp 0x115c9
leaq -0x3f8(%rbp), %rdi
callq 0x8a20
leaq -0x3d8(%rbp), %rdi
leaq -0x3dc(%rbp), %rsi
callq 0x3150
movq %rax, -0x428(%rbp)
jmp 0x115f1
movq -0x428(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32d0
movb %al, -0x429(%rbp)
jmp 0x1160f
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x1161b
jmp 0x11660
leaq -0x3f8(%rbp), %rdi
leaq -0x3dc(%rbp), %rsi
callq 0x11b60
jmp 0x11630
jmp 0x115d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x1176d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x11732
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x410(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
callq 0xca70
jmp 0x11680
movq -0x438(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x3e40
jmp 0x11695
leaq -0x410(%rbp), %rdi
callq 0x8aa0
movl -0x23c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x23c(%rbp)
movl -0x23c(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x11715
movl -0x23c(%rbp), %esi
movq 0x8908(%rip), %rdi      # 0x19fd8
callq 0x33f0
movq %rax, -0x440(%rbp)
jmp 0x116de
movq -0x440(%rbp), %rdi
movq 0x88dc(%rip), %rsi      # 0x19fc8
callq 0x3270
jmp 0x116f3
jmp 0x11715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x8aa0
jmp 0x11732
leaq -0x3f8(%rbp), %rdi
callq 0x8aa0
leaq -0x3d8(%rbp), %rdi
callq 0x31d0
jmp 0x1154e
leaq -0x3f8(%rbp), %rdi
callq 0x8aa0
leaq -0x3d8(%rbp), %rdi
callq 0x31d0
jmp 0x1176d
leaq -0x238(%rbp), %rdi
callq 0x3160
leaq -0x218(%rbp), %rdi
callq 0x3090
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x3160
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x248(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x256f7(%rip), %rsi     # 0x29004
leaq -0x208(%rbp), %rdi
movq %rdi, -0x268(%rbp)
movl $0x10, %edx
callq 0x3300
movq -0x268(%rbp), %rdi
leaq 0x256e2(%rip), %rsi     # 0x29015
callq 0x32b0
movq %rax, -0x260(%rbp)
jmp 0x3941
movq -0x260(%rbp), %rdi
movq 0x33659(%rip), %rsi     # 0x36fa8
callq 0x32e0
jmp 0x3956
movq -0x270(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rdi
callq 0x7fb0
movq %rax, -0x228(%rbp)
movq -0x220(%rbp), %rdi
callq 0x7fe0
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x8010
testb $0x1, %al
jne 0x39a6
jmp 0x3b1c
leaq -0x228(%rbp), %rdi
callq 0x8050
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rdi
callq 0x8070
movq %rax, -0x248(%rbp)
movq -0x240(%rbp), %rdi
callq 0x80a0
movq %rax, -0x250(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x80d0
testb $0x1, %al
jne 0x3a09
jmp 0x3af4
leaq -0x248(%rbp), %rdi
callq 0x8110
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ab2
movq -0x258(%rbp), %rax
movq (%rax), %rdi
callq 0x8130
movl %eax, -0x274(%rbp)
jmp 0x3a44
movl -0x274(%rbp), %esi
leaq -0x208(%rbp), %rdi
callq 0x34c0
movq %rax, -0x280(%rbp)
jmp 0x3a5f
movq -0x258(%rbp), %rax
movq (%rax), %rdi
callq 0x8140
movb %al, -0x281(%rbp)
jmp 0x3a76
movq -0x280(%rbp), %rdi
movb -0x281(%rbp), %al
movsbl %al, %esi
callq 0x3340
jmp 0x3a8d
jmp 0x3ae1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3420
jmp 0x3b3f
leaq -0x208(%rbp), %rdi
movl $0x30, %esi
callq 0x3340
movq %rax, -0x290(%rbp)
jmp 0x3acc
movq -0x290(%rbp), %rdi
movl $0x2e, %esi
callq 0x3340
jmp 0x3adf
jmp 0x3ae1
jmp 0x3ae3
leaq -0x248(%rbp), %rdi
callq 0x8160
jmp 0x39ed
movq 0x334ad(%rip), %rsi     # 0x36fa8
leaq -0x208(%rbp), %rdi
callq 0x32e0
jmp 0x3b09
jmp 0x3b0b
leaq -0x228(%rbp), %rdi
callq 0x8180
jmp 0x398a
leaq -0x208(%rbp), %rdi
callq 0x33d0
jmp 0x3b2a
leaq -0x208(%rbp), %rdi
callq 0x3420
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x331fb(%rip), %rdi     # 0x36fb8
leaq 0x25293(%rip), %rsi     # 0x29057
callq 0x32b0
movq -0x118(%rbp), %rdi
movq %rax, -0x110(%rbp)
callq 0x8250
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x30b0
movq %rax, %rdi
leaq 0x25275(%rip), %rsi     # 0x2906a
callq 0x32b0
movl $0x0, -0xc(%rbp)
movq -0x118(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x120(%rbp)
callq 0x8250
movq %rax, %rcx
movq -0x120(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ed0
movq -0x118(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8280
movq %rax, %rsi
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x82a0
movq -0x130(%rbp), %rdi
callq 0x8140
movb %al, -0x121(%rbp)
jmp 0x3e65
movb -0x121(%rbp), %al
movsbl %al, %esi
movq 0x33143(%rip), %rdi     # 0x36fb8
callq 0x3340
movq %rax, -0x138(%rbp)
jmp 0x3e83
movq -0x138(%rbp), %rdi
movl $0x20, %esi
callq 0x3340
jmp 0x3e96
leaq -0xf8(%rbp), %rdi
callq 0x26870
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x26870
jmp 0x3eec
movq 0x330e1(%rip), %rdi     # 0x36fb8
movq 0x330ca(%rip), %rsi     # 0x36fa8
callq 0x32e0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x100(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33c0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3500
movq -0x80(%rbp), %rdx
leaq 0x2574a(%rip), %rsi     # 0x2968f
leaq -0x38(%rbp), %rdi
callq 0x33b0
jmp 0x3f50
leaq -0x39(%rbp), %rdi
callq 0x32f0
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x98(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3560
movq -0x98(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x78(%rbp), %rdi
callq 0x32d0
jmp 0x3f97
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x3360
movq -0xb0(%rbp), %rdi
callq 0x3210
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3430
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rdi
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30a0
jmp 0x3ff5
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
testb $0x1, -0x11(%rbp)
jne 0x4044
jmp 0x4038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x32f0
jmp 0x4054
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x4054
movq -0x90(%rbp), %rdi
callq 0x3210
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x33c0
movq -0x18(%rbp), %rdi
callq 0x3490
testb $0x1, %al
jne 0x40b0
jmp 0x4123
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x18550
jmp 0x40bf
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x3360
movq -0xa8(%rbp), %rdi
callq 0x3210
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3f00
jmp 0x40ee
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3360
leaq -0x70(%rbp), %rdi
callq 0x3210
jmp 0x4154
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3210
jmp 0x417a
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x3f00
jmp 0x4135
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3360
leaq -0x90(%rbp), %rdi
callq 0x3210
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x416a
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x5a, -0x14(%rbp)
jne 0xf5b8
movl $0x1, -0x18(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0xf5f0
cmpl $0xb4, -0x14(%rbp)
jne 0xf5d1
movl $0x2, -0x18(%rbp)
movl $0x2, -0x4(%rbp)
jmp 0xf5f0
cmpl $0x10e, -0x14(%rbp)     # imm = 0x10E
jne 0xf5ea
movl $0x3, -0x18(%rbp)
movl $0x3, -0x4(%rbp)
jmp 0xf5f0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x290(%rbp)
movq %rdi, %rax
movq %rax, -0x288(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movq %rdi, -0x280(%rbp)
movl $0x8, %edx
callq 0x34a0
movq -0x280(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11730
jmp 0xf659
leaq -0x208(%rbp), %rdi
callq 0x11790
jmp 0xf667
movb $0x0, -0x209(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x117d0
jmp 0xf683
leaq -0x270(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x117d0
jmp 0xf698
leaq -0x271(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x11820
movq -0x290(%rbp), %rdi
movq -0x298(%rbp), %rcx
leaq -0x240(%rbp), %rsi
leaq -0x270(%rbp), %rdx
callq 0x11840
jmp 0xf6ce
leaq -0x271(%rbp), %rdi
callq 0x11940
leaq -0x270(%rbp), %rdi
callq 0x11960
leaq -0x240(%rbp), %rdi
callq 0x11960
movb $0x1, -0x209(%rbp)
testb $0x1, -0x209(%rbp)
jne 0xf7a8
jmp 0xf79c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xf7f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xf7e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xf7dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xf78e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x271(%rbp), %rdi
callq 0x11940
leaq -0x270(%rbp), %rdi
callq 0x11960
leaq -0x240(%rbp), %rdi
callq 0x11960
jmp 0xf7dc
movq -0x290(%rbp), %rdi
callq 0x11650
leaq -0x208(%rbp), %rdi
callq 0x11960
leaq -0x1c8(%rbp), %rdi
callq 0x11960
leaq -0x198(%rbp), %rdi
callq 0x31a0
movq -0x288(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x208(%rbp), %rdi
callq 0x11960
leaq -0x1c8(%rbp), %rdi
callq 0x11960
leaq -0x198(%rbp), %rdi
callq 0x31a0
movq -0x1d0(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x19ccf(%rip), %rsi     # 0x29511
callq 0x85b0
testb $0x1, %al
jne 0xf84d
jmp 0xf85f
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19cab(%rip), %rsi     # 0x29515
callq 0x85b0
testb $0x1, %al
jne 0xf875
jmp 0xf88b
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19c83(%rip), %rsi     # 0x29519
callq 0x85b0
testb $0x1, %al
jne 0xf8a1
jmp 0xf8b7
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x40, %rsi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19c5d(%rip), %rsi     # 0x2951f
callq 0x85b0
testb $0x1, %al
jne 0xf8cd
jmp 0xf8e3
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x60, %rsi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19c3c(%rip), %rsi     # 0x2952a
callq 0x85b0
testb $0x1, %al
jne 0xf8f9
jmp 0xf912
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x80, %rsi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19c14(%rip), %rsi     # 0x29531
callq 0x85b0
testb $0x1, %al
jne 0xf928
jmp 0xf93e
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0xa0, %rsi
callq 0x3160
jmp 0xf9af
movq -0x18(%rbp), %rdi
leaq 0x19bee(%rip), %rsi     # 0x29537
callq 0x85b0
testb $0x1, %al
jne 0xf954
jmp 0xf96a
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0xc0, %rsi
callq 0x3160
jmp 0xf9af
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3500
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x19bb7(%rip), %rsi     # 0x2953d
callq 0x33b0
jmp 0xf98d
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xf9af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xf9b9
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19b16(%rip), %rsi     # 0x29511
callq 0x85b0
testb $0x1, %al
jne 0xfa06
jmp 0xfa13
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19af7(%rip), %rsi     # 0x29515
callq 0x85b0
testb $0x1, %al
jne 0xfa29
jmp 0xfa3a
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19ad4(%rip), %rsi     # 0x29519
callq 0x85b0
testb $0x1, %al
jne 0xfa50
jmp 0xfa61
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19ab3(%rip), %rsi     # 0x2951f
callq 0x85b0
testb $0x1, %al
jne 0xfa77
jmp 0xfa88
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19a97(%rip), %rsi     # 0x2952a
callq 0x85b0
testb $0x1, %al
jne 0xfa9e
jmp 0xfab2
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19a74(%rip), %rsi     # 0x29531
callq 0x85b0
testb $0x1, %al
jne 0xfac8
jmp 0xfadc
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
leaq 0x19a50(%rip), %rsi     # 0x29537
callq 0x85b0
testb $0x1, %al
jne 0xfaf2
jmp 0xfb06
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x3040
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0xfb67
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0xe0, %rdi
callq 0x11980
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0xfbac
leaq -0x19(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3500
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x199ba(%rip), %rsi     # 0x2953d
callq 0x33b0
jmp 0xfb8a
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xfbcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xfbd9
movq -0x38(%rbp), %rdi
addq $0xe0, %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x119a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3160
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xfcd7
cmpl $0x0, -0x20(%rbp)
jne 0xfcb0
movl $0x1, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x1, -0x20(%rbp)
jne 0xfcc2
movl $0x2, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x2, -0x20(%rbp)
jne 0xfcd1
movl $0x3, -0x4(%rbp)
jmp 0xfd4f
jmp 0xfcd3
jmp 0xfcd5
jmp 0xfd4d
cmpl $0x1, -0x1c(%rbp)
jne 0xfd10
cmpl $0x0, -0x20(%rbp)
jne 0xfcec
movl $0x4, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x1, -0x20(%rbp)
jne 0xfcfb
movl $0x5, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x2, -0x20(%rbp)
jne 0xfd0a
movl $0x6, -0x4(%rbp)
jmp 0xfd4f
jmp 0xfd0c
jmp 0xfd0e
jmp 0xfd4b
cmpl $0x2, -0x1c(%rbp)
jne 0xfd49
cmpl $0x0, -0x20(%rbp)
jne 0xfd25
movl $0x7, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x1, -0x20(%rbp)
jne 0xfd34
movl $0x8, -0x4(%rbp)
jmp 0xfd4f
cmpl $0x2, -0x20(%rbp)
jne 0xfd43
movl $0x9, -0x4(%rbp)
jmp 0xfd4f
jmp 0xfd45
jmp 0xfd47
jmp 0xfd49
jmp 0xfd4b
jmp 0xfd4d
ud2
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::convertZone(int)
std::pair<int, int> Adapter::convertZone(int spot)
{
	if(spot == 1) return std::pair<int, int>(0,0);
	else if(spot == 2) return std::pair<int, int>(0,1);
	else if(spot == 3) return std::pair<int, int>(0,2);
	else if(spot == 4) return std::pair<int, int>(1,0);
	else if(spot == 5) return std::pair<int, int>(1,1);
	else if(spot == 6) return std::pair<int, int>(1,2);
	else if(spot == 7) return std::pair<int, int>(2,0);
	else if(spot == 8) return std::pair<int, int>(2,1);
	else if(spot == 9) return std::pair<int, int>(2,2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0xfd99
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x2, -0x14(%rbp)
jne 0xfdc3
movl $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x3, -0x14(%rbp)
jne 0xfded
movl $0x0, -0x28(%rbp)
movl $0x2, -0x2c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x4, -0x14(%rbp)
jne 0xfe17
movl $0x1, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x5, -0x14(%rbp)
jne 0xfe41
movl $0x1, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x6, -0x14(%rbp)
jne 0xfe6b
movl $0x1, -0x40(%rbp)
movl $0x2, -0x44(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x7, -0x14(%rbp)
jne 0xfe92
movl $0x2, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x8, -0x14(%rbp)
jne 0xfeb9
movl $0x2, -0x50(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x54(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
cmpl $0x9, -0x14(%rbp)
jne 0xfee0
movl $0x2, -0x58(%rbp)
movl $0x2, -0x5c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
callq 0x89e0
jmp 0xfef2
jmp 0xfee2
jmp 0xfee4
jmp 0xfee6
jmp 0xfee8
jmp 0xfeea
jmp 0xfeec
jmp 0xfeee
jmp 0xfef0
ud2
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %r9, -0x98(%rbp)
movq %r8, -0x90(%rbp)
movq %rcx, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rsi, -0x78(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x18670
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x33c0
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x58(%rbp)
callq 0x23c40
jmp 0x131cc
movq -0x70(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x23c40
jmp 0x131e2
movq -0x70(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x23dd0
jmp 0x131f8
movl $0xe8, %edi
callq 0x32c0
movq %rax, -0xb0(%rbp)
jmp 0x1320b
movq -0x98(%rbp), %rdi
callq 0x15100
movl %eax, -0xb4(%rbp)
jmp 0x1321f
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdi
callq 0x250d0
jmp 0x13233
movq -0x70(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rsi
callq 0x1b3d0
jmp 0x13259
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl $0x7, 0x18(%rdi)
addq $0x40, %rdi
callq 0x15120
jmp 0x13273
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x60, %rdi
callq 0x15120
jmp 0x13289
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x3040
jmp 0x1329c
movq -0x90(%rbp), %rsi
movq -0x70(%rbp), %rdi
subq $-0x80, %rdi
callq 0x88e0
jmp 0x132b2
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1332c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13317
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1330b
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x32a0
movq -0xa8(%rbp), %rdi
callq 0x24220
movq -0xa0(%rbp), %rdi
callq 0x23c60
movq -0x58(%rbp), %rdi
callq 0x23c60
movq -0x68(%rbp), %rdi
callq 0x3210
movq -0x60(%rbp), %rdi
callq 0x18740
movq -0x38(%rbp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, -0x278(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x153c3(%rip), %rsi     # 0x29004
leaq -0x210(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movl $0x10, %edx
callq 0x3300
movq -0x270(%rbp), %rdi
leaq 0x153ae(%rip), %rsi     # 0x29015
callq 0x32b0
movq %rax, -0x268(%rbp)
jmp 0x13c75
movq -0x268(%rbp), %rdi
movq 0x23325(%rip), %rsi     # 0x36fa8
callq 0x32e0
jmp 0x13c8a
movq -0x278(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7fb0
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7fe0
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x8010
testb $0x1, %al
jne 0x13cda
jmp 0x13e50
leaq -0x230(%rbp), %rdi
callq 0x8050
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rdi
callq 0x8070
movq %rax, -0x250(%rbp)
movq -0x248(%rbp), %rdi
callq 0x80a0
movq %rax, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x80d0
testb $0x1, %al
jne 0x13d3d
jmp 0x13e28
leaq -0x250(%rbp), %rdi
callq 0x8110
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13de6
movq -0x260(%rbp), %rax
movq (%rax), %rdi
callq 0x8130
movl %eax, -0x27c(%rbp)
jmp 0x13d78
movl -0x27c(%rbp), %esi
leaq -0x210(%rbp), %rdi
callq 0x34c0
movq %rax, -0x288(%rbp)
jmp 0x13d93
movq -0x260(%rbp), %rax
movq (%rax), %rdi
callq 0x8140
movb %al, -0x289(%rbp)
jmp 0x13daa
movq -0x288(%rbp), %rdi
movb -0x289(%rbp), %al
movsbl %al, %esi
callq 0x3340
jmp 0x13dc1
jmp 0x13e15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3420
jmp 0x13e73
leaq -0x210(%rbp), %rdi
movl $0x30, %esi
callq 0x3340
movq %rax, -0x298(%rbp)
jmp 0x13e00
movq -0x298(%rbp), %rdi
movl $0x2e, %esi
callq 0x3340
jmp 0x13e13
jmp 0x13e15
jmp 0x13e17
leaq -0x250(%rbp), %rdi
callq 0x8160
jmp 0x13d21
movq 0x23179(%rip), %rsi     # 0x36fa8
leaq -0x210(%rbp), %rdi
callq 0x32e0
jmp 0x13e3d
jmp 0x13e3f
leaq -0x230(%rbp), %rdi
callq 0x8180
jmp 0x13cbe
leaq -0x210(%rbp), %rdi
callq 0x33d0
jmp 0x13e5e
leaq -0x210(%rbp), %rdi
callq 0x3420
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x34f0
nop
// File: 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
subq $0x80, %rsp
movl %r9d, %eax
movl %ecx, -0x78(%rbp)
movl %edx, %ecx
movl -0x78(%rbp), %edx
movl %ecx, -0x74(%rbp)
movq %rsi, %rcx
movl -0x74(%rbp), %esi
movq %rcx, -0x68(%rbp)
movq %rdi, %r9
movq -0x68(%rbp), %rdi
movb %al, %cl
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
andb $0x1, %al
movb %al, -0x1e(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0xe8, %edi
callq 0x32c0
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x15100
movl %eax, -0x54(%rbp)
jmp 0x13ef4
movl -0x54(%rbp), %esi
movq -0x60(%rbp), %rdi
callq 0x250d0
jmp 0x13f02
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13f44
movq -0x28(%rbp), %rdi
callq 0x268d0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x13f11
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x32a0
jmp 0x13fad
leaq -0x40(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x119c0
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rsi
callq 0x1b3d0
testb $0x1, -0x1d(%rbp)
je 0x13f8f
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq 0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
callq 0x1c690
testb $0x1, -0x1e(%rbp)
je 0x13fa4
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1b390
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rsi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x8ca0
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
callq 0x3150
movq %rax, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x18384
movq 0x1ec54(%rip), %rax     # 0x36fc0
movq (%rax), %rdi
leaq 0x11343(%rip), %rsi     # 0x296b9
movb $0x0, %al
callq 0x33e0
xorl %edi, %edi
callq 0x3350
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jge 0x183b2
movq -0x20(%rbp), %rdi
leaq 0x11321(%rip), %rsi     # 0x296ce
callq 0x18420
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movl $0x10, %esi
callq 0x34d0
movq -0x20(%rbp), %rax
movw $0x2, 0xc(%rax)
movq 0x20(%rax), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdi
movq %rax, %rsi
addq $0xc, %rsi
addq $0x4, %rsi
movq 0x20(%rax), %rax
movslq 0x14(%rax), %rdx
callq 0x3330
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movzwl %ax, %edi
callq 0x3070
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0xe(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl (%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x3250
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1848f
movq -0x18(%rbp), %rdi
leaq 0x1125b(%rip), %rsi     # 0x296e3
callq 0x18420
jmp 0x184a7
movq 0x1eb02(%rip), %rax     # 0x36f98
movq (%rax), %rdi
leaq 0x11254(%rip), %rsi     # 0x296f4
movb $0x0, %al
callq 0x33e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x34d0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movl $0x3e7, %edx            # imm = 0x3E7
xorl %eax, %eax
movl %eax, %ecx
callq 0x3090
movq -0x18(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x24(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x3170
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x18540
movq -0x18(%rbp), %rdi
leaq 0x111dc(%rip), %rsi     # 0x29717
callq 0x18420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33c0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x34d0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movl (%rax), %edi
movl $0x3e7, %edx            # imm = 0x3E7
callq 0x33f0
movq %rax, -0x30(%rbp)
jmp 0x185ac
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x185e8
movq -0x40(%rbp), %rdi
leaq 0x11167(%rip), %rsi     # 0x2972f
callq 0x18420
jmp 0x185cf
jmp 0x185fd
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3210
jmp 0x1861a
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
callq 0x33a0
jmp 0x185fb
jmp 0x185fd
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x18610
movq -0x50(%rbp), %rdi
callq 0x3210
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x20130
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa0, -0x14(%rbp)
jge 0x18730
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20150
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x20170
jmp 0x186c1
movl $0x0, -0x40(%rbp)
cmpl $0xa0, -0x40(%rbp)
jge 0x18719
movq -0x48(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x201e0
jmp 0x186ec
jmp 0x186ee
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x186c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x17200
movq -0x48(%rbp), %rdi
callq 0x20250
jmp 0x18736
leaq -0x30(%rbp), %rdi
callq 0x17200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18698
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34f0
nop