LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintPost(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintPost(Node<T>* n) {
	if(n != 0) {
		traversalPrintPost(n->getLeftChild());
		traversalPrintPost(n->getRightChild());
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;		
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x4f37
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x66b4
movq (%rax), %rsi
movq %r14, %rdi
callq 0x4e8a
movq %rbx, %rdi
callq 0x66c0
movq (%rax), %rsi
movq %r14, %rdi
callq 0x4e8a
movq 0x8109(%rip), %rdi      # 0xcfd8
leaq 0x3297(%rip), %rsi      # 0x816d
callq 0x2140
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x668e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x20a0
movq 0x80ca(%rip), %rdi      # 0xcfd8
leaq 0x3262(%rip), %rsi      # 0x8177
callq 0x2140
movq %rax, %r14
movq %rbx, %rdi
callq 0x669c
movq %r14, %rdi
movl %eax, %esi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintIn(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintIn(Node<T>* n) {
	if(n != 0) {
		traversalPrintIn(n->getLeftChild());		
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;
		//cout << "It's address is " << n << endl;
		traversalPrintIn(n->getRightChild());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x5007
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x66b4
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4f54
movq 0x8050(%rip), %rdi      # 0xcfd8
leaq 0x31de(%rip), %rsi      # 0x816d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x668e
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x800d(%rip), %rdi      # 0xcfd8
leaq 0x31a5(%rip), %rsi      # 0x8177
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x669c
movq %r15, %rdi
movl %eax, %esi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x66c0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4f54
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::leftRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::leftRotation(Node<T>* cn, Node<T>** parent) {
	cout << "Left Rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getRightChild();
	Node<T>* tempLC = newRoot->getLeftChild();
	*parent = newRoot;
	newRoot->setLeftChild(*cn);
	cn->setRightChild(*tempLC);	
	
	//special case
	if (tempLC != 0 && newRoot->getRightChild() != 0) newRoot->getRightChild()->incBalance();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x7f98(%rip), %rdi      # 0xcfd8
leaq 0x313c(%rip), %rsi      # 0x8183
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x668e
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x66c0
movq (%rax), %r15
movq %r15, %rdi
callq 0x66b4
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x66ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0x66c6
movq %r15, %rdi
callq 0x66c0
cmpq $0x0, (%rax)
je 0x50c9
movq %r15, %rdi
callq 0x66c0
movq (%rax), %rdi
callq 0x66a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::rightRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::rightRotation(Node<T>* cn, Node<T>** parent) {	
	cout << "Right rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getLeftChild();
	Node<T>* tempRC = newRoot->getRightChild();	
	*parent = newRoot;
	newRoot->setRightChild(*cn);
	cn->setLeftChild(*tempRC);	

	//special case
	if (tempRC != 0 && newRoot->getLeftChild() != 0) newRoot->getLeftChild()->decBalance();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x7ed6(%rip), %rdi      # 0xcfd8
leaq 0x308c(%rip), %rsi      # 0x8195
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x668e
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x66b4
movq (%rax), %r15
movq %r15, %rdi
callq 0x66c0
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x66c6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x66ba
movq %r15, %rdi
callq 0x66b4
cmpq $0x0, (%rax)
je 0x518b
movq %r15, %rdi
callq 0x66b4
movq (%rax), %rdi
callq 0x66a4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<double>::find(double)
bool AVLTree<T>::find(T v) {
	Node<T>** curr =&root;
	
	while(*curr!=0 && (*curr)->getValue()!= v) {
		if (v < (*curr)->getValue()) {
			curr = &((*curr)->getLeftChild());
		} else if (v > (*curr)->getValue()) {
			curr = &((*curr)->getRightChild());
		}    
	}
	
	if (*curr==0) {
		return false;
	}
	else {
		return true;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4598
callq 0x65f2
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rdi
jne 0x4560
jnp 0x459a
callq 0x65f2
ucomisd 0x8(%rsp), %xmm0
movq (%rbx), %rdi
ja 0x458e
callq 0x65f2
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4542
movq (%rbx), %rdi
callq 0x661c
movq %rax, %rbx
jmp 0x4542
callq 0x6610
movq %rax, %rbx
jmp 0x4542
xorl %edi, %edi
testq %rdi, %rdi
setne %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/Node.cpp
// Function: Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node<T>::Node(T v) {
	value = v;
	leftChild = 0;
	rightChild = 0;
	parent = 0;
	balance = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x20d0
andl $0x0, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
andq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/TwoDArray.cpp
// Function: TwoDArray<double>::print()
void TwoDArray<T>::print() {	
	for(int i = 0; i < numRows; ++i) {
		for (int j = 0; j < numColumns; ++j) {
			cout << theArray[i][j]	<< " ";
		}
		cout << endl;
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x6342(%rip), %r14      # 0xcfd8
leaq 0x1390(%rip), %r15      # 0x802d
movslq 0x18(%rbx), %rax
cmpq %rax, %r12
jge 0x6ce6
imulq $0x18, %r12, %r13
xorl %ebp, %ebp
movslq 0x1c(%rbx), %rax
cmpq %rax, %rbp
jge 0x6cd9
movq (%rbx), %rax
movq (%rax,%r13), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
incq %rbp
jmp 0x6cac
movq %r14, %rdi
callq 0x20b0
incq %r12
jmp 0x6c9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adhipradhana[P]sliding-window-protocol/src/sendfile.cpp
// Function: get_ack()
void get_ack() {
    char ack[ACK_LENGTH];
    unsigned int seq_num;
    bool is_check_sum_valid, is_nak;

    while(true) {
        int ack_size = recvfrom(sock, ack, ACK_LENGTH, MSG_WAITALL,(struct sockaddr *)&from, &sock_length);
        if (ack_size < 0) {
            cout << "Packet loss on receiving message" << endl;
            // exit(1);
        }

        // Create ack from buffer
        read_ack(ack, &is_nak, &seq_num, &is_check_sum_valid);

        if (is_check_sum_valid) {
            mt.lock();
            if (seq_num >= lar + 1 && seq_num <= lfs) {
                if (!is_nak) {
                    has_ack_received[seq_num - (lar + 1)] = true;
                    cout << "Receiving ACK : " << seq_num << endl;
                } else {
                    packet_send_time[seq_num - (lar + 1)] = TMIN;
                    cout << "Receiving NAK : " << seq_num << endl;
                }
            } else {
                cout << "ACK out of bound " << seq_num << endl;
            }
            mt.unlock();
        } else {
            cout << "ERROR ACK : " << seq_num << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x36(%rbp), %r15
leaq -0x30(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq 0x2c70(%rip), %r12      # 0x51a8
movq 0x2a91(%rip), %r13      # 0x4fd0
movl 0x2bf7(%rip), %edi      # 0x513c
movq %r15, %rsi
pushq $0x6
popq %rdx
movl $0x100, %ecx            # imm = 0x100
leaq 0x2c05(%rip), %r8       # 0x515c
leaq 0x2be6(%rip), %r9       # 0x5144
callq 0x20e0
testl %eax, %eax
jns 0x257e
movq %r13, %rdi
leaq 0xa93(%rip), %rsi       # 0x3004
callq 0x2120
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x24e2
cmpb $0x1, -0x2a(%rbp)
jne 0x25e6
movq %r12, %rdi
callq 0x2b7e
movl -0x30(%rbp), %ecx
movl 0x2bd9(%rip), %edx      # 0x5180
incl %edx
movl %ecx, %eax
leaq 0xa95(%rip), %rsi       # 0x3047
subl %edx, %eax
jb 0x261f
leaq 0xa8a(%rip), %rsi       # 0x3047
cmpl 0x2bc1(%rip), %ecx      # 0x5184
ja 0x261f
cmpb $0x0, -0x29(%rbp)
je 0x260d
movq 0x2bc6(%rip), %rcx      # 0x5198
movq 0x2bc7(%rip), %rdx      # 0x51a0
movq %rdx, (%rcx,%rax,8)
leaq 0xa52(%rip), %rsi       # 0x3036
jmp 0x261f
movq %r13, %rdi
leaq 0xa69(%rip), %rsi       # 0x3059
callq 0x2120
movl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2090
jmp 0x253f
movq 0x2b74(%rip), %rcx      # 0x5188
movb $0x1, (%rcx,%rax)
leaq 0xa06(%rip), %rsi       # 0x3025
movq %r13, %rdi
callq 0x2120
movl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2090
movq %r12, %rdi
callq 0x20d0
jmp 0x253f
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_07.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::string s[] = { "sss" };
	std::cout << getSize(s) << std::endl;

	char c[] = "s";
	std::cout << getSize(c) << std::endl;
	// the output is 2, as '\0' is added at the end of the array
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0xe18(%rip), %rsi       # 0x2004
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
movq 0x2dd8(%rip), %rdi      # 0x3fd8
pushq $0x1
popq %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1050
movq 0x2dc1(%rip), %rdi      # 0x3fd8
pushq $0x2
popq %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x123b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/LiGaCu[P]Distributed_System_to_Compute_the_Shortest_Path/aws.cpp
// Function: getTCPsockandbind(addrinfo*)
int getTCPsockandbind(struct addrinfo *servinfo)
{
    int sockfd;
    struct addrinfo *p;
    int reuseaddr=1;

    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) 
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
        {
            perror("server: socket");
            continue;
        }
        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) 
        {
            perror("setsockopt");
            exit(1);
        }
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
        {
            close(sockfd);
            perror("server: bind");
            continue;
        }
        break;
    }
    if (p == NULL) 
    {
        fprintf(stderr, "server: failed to bind\n");
        exit(1);
    }

    return sockfd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, (%r14)
leaq 0x160e(%rip), %rbp      # 0x430c
pushq $0x2
popq %r15
pushq $0x4
popq %r12
testq %rbx, %rbx
je 0x2d7c
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x2070
movq %rbp, %rdi
cmpl $-0x1, %eax
je 0x2d5f
movl %eax, %r13d
movl %eax, %edi
pushq $0x1
popq %rsi
movl %r15d, %edx
movq %r14, %rcx
movl %r12d, %r8d
callq 0x2270
cmpl $-0x1, %eax
je 0x2d9a
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movl %r13d, %edi
callq 0x2060
cmpl $-0x1, %eax
jne 0x2d6a
movl %r13d, %edi
callq 0x22b0
leaq 0x15c7(%rip), %rdi      # 0x4326
callq 0x2140
movq 0x28(%rbx), %rbx
jmp 0x2d06
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3255(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x15a6(%rip), %rdi      # 0x4333
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
jmp 0x2da6
leaq 0x157a(%rip), %rdi      # 0x431b
callq 0x2140
pushq $0x1
popq %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/LiGaCu[P]Distributed_System_to_Compute_the_Shortest_Path/aws.cpp
// Function: interpUDPmsg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int*, int*, char*, char*)
void interpUDPmsg(std::string &mapbuff, std::string &mapinfo, int *receivedA, int *receivedB, char *msgA, char *msgB)
{
    int pos;
    std::string markA("serverA");
    std::string markB("serverB");

    pos = mapbuff.find(markA);
    if( pos != -1 )
    {
        *receivedA = 1;
        if ( mapbuff[pos+markA.length()] != '!')
        {
            *msgA = 'y';
            mapinfo = mapbuff.substr(pos+markA.length()+1,mapbuff.find(markB,pos));
        }
        else
            *msgA = mapbuff[pos+markA.length()+1];
    }
    
    pos = mapbuff.find(markB);
    if( pos != -1 )
    {
        *receivedB= 1;
        if ( mapbuff[pos+markB.length()] != '!')
        {
            *msgB = 'y';
            mapinfo = mapbuff.substr(pos+markB.length()+1,mapbuff.find(markA,pos));
        }
        else
            *msgB = mapbuff[pos+markA.length()+1];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14ad(%rip), %rsi      # 0x438c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x335a
leaq 0x155f(%rip), %rsi      # 0x4454
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x335a
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x22c0
cmpl $-0x1, %eax
je 0x2f7d
movl $0x1, (%rbp)
movslq %eax, %rdx
movq 0x30(%rsp), %rbp
addq %rdx, %rbp
movq (%r14), %rax
cmpb $0x21, (%rax,%rbp)
jne 0x2f3d
movb 0x1(%rax,%rbp), %al
movb %al, (%r13)
jmp 0x2f7d
movb $0x79, (%r13)
incq %rbp
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x22c0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x2170
leaq 0x48(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21c0
movq %r13, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x22c0
cmpl $-0x1, %eax
je 0x2ffe
movl $0x1, (%r12)
movslq %eax, %rdx
movq 0x10(%rsp), %r12
addq %rdx, %r12
movq (%r14), %rax
cmpb $0x21, (%rax,%r12)
jne 0x2fbf
movq 0x30(%rsp), %rcx
addq %rdx, %rax
movb 0x1(%rcx,%rax), %al
movb %al, (%r15)
jmp 0x2ffe
movb $0x79, (%r15)
incq %r12
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x22c0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x2170
leaq 0x48(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x20c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3023
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x3035
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playsaw N fs <device> <channelOffset> <time>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    channelOffset = an optional channel offset on the device (default = 0),\n";
  std::cout << "    and time = an optional time duration in seconds (default = no limit).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x7a24(%rip), %rbx      # 0xcfc8
leaq 0x3a8d(%rip), %rsi      # 0x9038
movq %rbx, %rdi
callq 0x51d0
leaq 0x3ab5(%rip), %rsi      # 0x906f
movq %rbx, %rdi
callq 0x51d0
leaq 0x3ac9(%rip), %rsi      # 0x9092
movq %rbx, %rdi
callq 0x51d0
leaq 0x3ad5(%rip), %rsi      # 0x90ad
movq %rbx, %rdi
callq 0x51d0
leaq 0x3afa(%rip), %rsi      # 0x90e1
movq %rbx, %rdi
callq 0x51d0
leaq 0x3b38(%rip), %rsi      # 0x912e
movq %rbx, %rdi
callq 0x51d0
xorl %edi, %edi
callq 0x5240
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: errorCallback(RtAudioError::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void errorCallback( RtAudioError::Type type, const std::string &errorText )
{
  // This example error handling function does exactly the same thing
  // as the embedded RtAudio::error() function.
  std::cout << "in errorCallback" << std::endl;
  if ( type == RtAudioError::WARNING )
    std::cerr << '\n' << errorText << "\n\n";
  else if ( type != RtAudioError::WARNING )
    throw( RtAudioError( errorText, type ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x79b3(%rip), %rdi      # 0xcfc8
leaq 0x3b5e(%rip), %rsi      # 0x917a
callq 0x51d0
movq %rax, %rdi
callq 0x50d0
testl %ebp, %ebp
jne 0x565a
movq 0x79bc(%rip), %rdi      # 0xcff0
pushq $0xa
popq %rsi
callq 0x5200
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51a0
leaq 0x3e4b(%rip), %rsi      # 0x9499
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51d0
pushq $0x30
popq %rdi
callq 0x50e0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5a06
leaq 0x758f(%rip), %rsi      # 0xcc08
leaq 0x3b6(%rip), %rdx       # 0x5a36
movq %r14, %rdi
callq 0x5380
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: saw(void*, void*, unsigned int, double, unsigned int, void*)
int saw( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
         double /*streamTime*/, RtAudioStreamStatus status, void *data )
{
  unsigned int i, j;
  extern unsigned int channels;
  MY_TYPE *buffer = (MY_TYPE *) outputBuffer;
  double *lastValues = (double *) data;

  if ( status )
    std::cout << "Stream underflow detected!" << std::endl;

  double increment;
  for ( j=0; j<channels; j++ ) {
    increment = BASE_RATE * (j+1+(j*0.1));
    for ( i=0; i<nBufferFrames; i++ ) {
      *buffer++ = (MY_TYPE) (lastValues[j] * SCALE * 0.5);
      lastValues[j] += increment;
      if ( lastValues[j] >= 1.0 ) lastValues[j] -= 2.0;
    }
  }

  frameCounter += nBufferFrames;
  if ( checkCount && ( frameCounter >= nFrames ) ) return callbackReturnValue;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movl %edx, %ebx
movq %rdi, %r15
testl %ecx, %ecx
je 0x56b4
movq 0x7928(%rip), %rdi      # 0xcfc8
leaq 0x3ae4(%rip), %rsi      # 0x918b
callq 0x51d0
movq %rax, %rdi
callq 0x50d0
movl 0x7b72(%rip), %eax      # 0xd22c
xorl %ecx, %ecx
movsd 0x3944(%rip), %xmm0     # 0x9008
movsd 0x3944(%rip), %xmm1     # 0x9010
movsd 0x3944(%rip), %xmm2     # 0x9018
movsd 0x3944(%rip), %xmm3     # 0x9020
movsd 0x3944(%rip), %xmm4     # 0x9028
movsd 0x3944(%rip), %xmm5     # 0x9030
cmpq %rax, %rcx
je 0x5770
leaq 0x1(%rcx), %rdx
movl %edx, %esi
cvtsi2sd %rsi, %xmm7
movl %ecx, %esi
cvtsi2sd %rsi, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm7, %xmm6
mulsd %xmm1, %xmm6
movl %ebx, %esi
subl $0x1, %esi
jb 0x5768
movsd (%r14,%rcx,8), %xmm7
movapd %xmm7, %xmm8
mulsd %xmm2, %xmm8
mulsd %xmm3, %xmm8
cvttsd2si %xmm8, %edi
movw %di, (%r15)
addq $0x2, %r15
addsd %xmm6, %xmm7
movapd %xmm7, %xmm8
addsd %xmm4, %xmm8
movapd %xmm5, %xmm9
cmpnlesd %xmm7, %xmm9
andpd %xmm9, %xmm7
andnpd %xmm8, %xmm9
orpd %xmm7, %xmm9
movlpd %xmm9, (%r14,%rcx,8)
jmp 0x5711
movq %rdx, %rcx
jmp 0x56ec
addl 0x7aea(%rip), %ebx      # 0xd260
movl %ebx, 0x7ae4(%rip)      # 0xd260
cmpl 0x7ae6(%rip), %ebx      # 0xd268
setae %al
andb 0x7ad9(%rip), %al       # 0xd264
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::Game()
Game::Game()
{
    turnCounter = 20;
    setGameOver(false);
    tempSpaceType = ' ';
    map = new World_Map;
    testSubject = new Player;
   
    //sets the starting space to 0,0
    setPlayerSpace();
    //prints the player's character on the board
    playerSpace->setSpaceTypeIdentifier('*');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x14, (%rdi)
movw $0x2000, 0x4(%rdi)      # imm = 0x2000
pushq $0x28
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rax, %rdi
callq 0x42b8
movq %r14, 0x18(%rbx)
pushq $0x48
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rax, %rdi
callq 0x3cb0
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x25ac
movq 0x10(%rbx), %rdi
pushq $0x2a
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37d0
movq %rax, %rbx
pushq $0x48
jmp 0x2594
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::~Game()
Game::~Game()
{
    delete testSubject;
    testSubject = NULL;

    delete map;
    map = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2602
movq %r14, %rdi
callq 0x3d80
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0x21b0
andq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2623
movq %r14, %rdi
callq 0x456e
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x21b0
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::gameIntroduction[abi:cxx11]()
std::string Game::gameIntroduction()
{
    std::string introText;

    introText = "\nHello ";
    introText += testSubject->getName();
    introText += ".\n\n";
    introText += "My name is GLaDOS. I am your best friend and overlord.\n\n";
    introText += "I am glad to see that you are finally awake.\n";
    introText += "I have been waiting so long for you to enjoy the new ";
    introText += "Test Chamber that I have set up for you.\n\n"; 
    introText += "You have done well with the other tests, but this chamber ";
    introText += "will certainly kill you.\n\n";
    introText += "Haha. Just kidding. You will only be permanently disfigured.\n\n";
    introText += "You have 20 moves to escape the chamber. \n\n";
    introText += "If you require assistance, I will grudingly give it if you ";
    introText += "if you press 'h' and hit enter.\n\n";
    introText += "Now, press Enter to step outside and begin the test.\n\n";

    return introText;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x39ac(%rip), %rsi      # 0x6064
callq 0x22b0
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3dac
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x22c0
leaq 0x8(%rsp), %rdi
callq 0x20d0
leaq 0x3adc(%rip), %rsi      # 0x61c5
movq %rbx, %rdi
callq 0x22a0
leaq 0x3974(%rip), %rsi      # 0x606c
movq %rbx, %rdi
callq 0x22a0
leaq 0x399e(%rip), %rsi      # 0x60a5
movq %rbx, %rdi
callq 0x22a0
leaq 0x39bd(%rip), %rsi      # 0x60d3
movq %rbx, %rdi
callq 0x22a0
leaq 0x39e4(%rip), %rsi      # 0x6109
movq %rbx, %rdi
callq 0x22a0
leaq 0x3a00(%rip), %rsi      # 0x6134
movq %rbx, %rdi
callq 0x22a0
leaq 0x3a2c(%rip), %rsi      # 0x616f
movq %rbx, %rdi
callq 0x22a0
leaq 0x3a38(%rip), %rsi      # 0x618a
movq %rbx, %rdi
callq 0x22a0
leaq 0x3a68(%rip), %rsi      # 0x61c9
movq %rbx, %rdi
callq 0x22a0
leaq 0x3a85(%rip), %rsi      # 0x61f5
movq %rbx, %rdi
callq 0x22a0
leaq 0x3ab2(%rip), %rsi      # 0x6231
movq %rbx, %rdi
callq 0x22a0
leaq 0x3ac5(%rip), %rsi      # 0x6253
movq %rbx, %rdi
callq 0x22a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x27b5
jmp 0x27b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::displayHelpMenu[abi:cxx11]()
std::string Game::displayHelpMenu()
{
    std::string helpMenuText;

    helpMenuText = "\nMOVEMENT               ACTIONS\n";
    helpMenuText += "--------               -------\n";
    helpMenuText += "Move up = w            Make Portal = e\n";
    helpMenuText += "Move down = s          View Backpack = b\n";
    helpMenuText += "Move left = a          View Map Legend= m\n";
    helpMenuText += "Move right = d         View Remaining Turns = t\n";
    helpMenuText += "                       View Controls = h\n"; 
    helpMenuText += "                       Exit Game = x\n\n";

    return helpMenuText;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x430b(%rip), %rsi      # 0x7201
callq 0x22b0
leaq 0x4320(%rip), %rsi      # 0x7222
movq %rbx, %rdi
callq 0x22a0
leaq 0x4331(%rip), %rsi      # 0x7242
movq %rbx, %rdi
callq 0x22a0
leaq 0x434a(%rip), %rsi      # 0x726a
movq %rbx, %rdi
callq 0x22a0
leaq 0x4365(%rip), %rsi      # 0x7294
movq %rbx, %rdi
callq 0x22a0
leaq 0x4381(%rip), %rsi      # 0x72bf
movq %rbx, %rdi
callq 0x22a0
leaq 0x43a3(%rip), %rsi      # 0x72f0
movq %rbx, %rdi
callq 0x22a0
leaq 0x43be(%rip), %rsi      # 0x731a
movq %rbx, %rdi
callq 0x22a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::makeMove(char)
void Game::makeMove(char userDirectionInput)
{
    //integrity check to ensure the player does not move out of bounds or on
    //top of an obstacle
    if (isOutOfBounds(userDirectionInput) || isObstacle(userDirectionInput))
    {
        std::cout << "Seriously? You clearly can't go that way. Try again." << std::endl;
    }
    else
    {
        //switch to change the player's coordinates based on chosen direction
        switch (userDirectionInput)
        {
            case 'w': testSubject->decrementCurrentX();
                      break;
            case 's': testSubject->incrementCurrentX();
                      break;
            case 'a': testSubject->decrementCurrentY();
                      break;
            case 'd': testSubject->incrementCurrentY();
                      break;
        }

        //set the player space based on new coordinates
        setPlayerSpace();
       
        //check for a special space type interaction
        playerSpace->spaceTypeSpecialInteraction(testSubject, map->getItem(3), map->getItem(2));
      
        //print the player's character on the map
        showPosition(userDirectionInput);

        //show the map
        map->showMap();
       
        //remove one turn from the total allowed
        turnCounter--;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3068
testb %al, %al
jne 0x2faa
movsbl %bpl, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x30ee
testb %al, %al
je 0x2fcd
movq 0x801f(%rip), %rdi      # 0xafd0
leaq 0x4389(%rip), %rsi      # 0x7341
callq 0x2190
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
cmpl $0x61, %ebp
je 0x3002
cmpl $0x64, %ebp
je 0x2fec
cmpl $0x73, %ebp
je 0x2ff7
cmpl $0x77, %ebp
jne 0x300b
movq 0x8(%rbx), %rdi
callq 0x3dce
jmp 0x300b
movq 0x8(%rbx), %rdi
callq 0x3dca
jmp 0x300b
movq 0x8(%rbx), %rdi
callq 0x3dc6
jmp 0x300b
movq 0x8(%rbx), %rdi
callq 0x3dd2
movq %rbx, %rdi
callq 0x25ac
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x4632
movq %rax, %r12
movq 0x18(%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x4632
movq (%r15), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq *0x10(%r8)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x31b8
movq 0x18(%rbx), %rdi
callq 0x4f78
decl (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::isOutOfBounds(char)
bool Game::isOutOfBounds(char intendedInput)
{
    //executes if the player would move out of bounds upwards
    if (testSubject->getCurrentX() == 0 && intendedInput == 'w')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds downwards
    if (testSubject->getCurrentX() == map->getRows() - 1 && intendedInput == 's')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds to the left
    if (testSubject->getCurrentY() == 0 && intendedInput == 'a')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds to the right
    if (testSubject->getCurrentY() == map->getColumns() - 1 && intendedInput == 'd')
    {
        return true; 
    }

    //if the player chooses not to move, do nothing
    if (intendedInput == 'n')
    {
        return false;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x3dbe
movb $0x1, %bpl
cmpb $0x77, %bl
jne 0x3089
testl %eax, %eax
je 0x30e1
movq 0x8(%r14), %rdi
callq 0x3dbe
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x4624
cmpb $0x73, %bl
jne 0x30aa
decl %eax
cmpl %eax, %r15d
je 0x30e1
movq 0x8(%r14), %rdi
callq 0x3dc2
cmpb $0x61, %bl
jne 0x30bc
testl %eax, %eax
je 0x30e1
movq 0x8(%r14), %rdi
callq 0x3dc2
movl %eax, %ebp
movq 0x18(%r14), %rdi
callq 0x4628
decl %eax
cmpl %eax, %ebp
sete %al
cmpb $0x64, %bl
sete %bpl
andb %al, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::isObstacle(char)
bool Game::isObstacle(char intendedInput)
{
    switch (intendedInput)
    {
        //case if the player would move onto an obstacle upwards
        case 'w': if (playerSpace->getSpaceUp()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceUp()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle downwards
        case 's': if (playerSpace->getSpaceBottom()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceBottom()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle to the left
        case 'a': if (playerSpace->getSpaceLeft()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceLeft()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle to the right
        case 'd': if (playerSpace->getSpaceRight()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceRight()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player chooses not to move 
        case 'x': return false;
    }

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x61, %esi
je 0x3180
cmpl $0x64, %esi
je 0x313c
cmpl $0x73, %esi
je 0x315e
cmpl $0x78, %esi
je 0x31ac
cmpl $0x77, %esi
jne 0x31ac
movq 0x10(%r14), %rdi
callq 0x3792
movq %rax, %rdi
callq 0x378a
movb $0x1, %bl
cmpb $0x58, %al
je 0x31ae
movq 0x10(%r14), %rdi
callq 0x3792
jmp 0x31a0
movq 0x10(%r14), %rdi
callq 0x37a4
movq %rax, %rdi
callq 0x378a
movb $0x1, %bl
cmpb $0x58, %al
je 0x31ae
movq 0x10(%r14), %rdi
callq 0x37a4
jmp 0x31a0
movq 0x10(%r14), %rdi
callq 0x3798
movq %rax, %rdi
callq 0x378a
movb $0x1, %bl
cmpb $0x58, %al
je 0x31ae
movq 0x10(%r14), %rdi
callq 0x3798
jmp 0x31a0
movq 0x10(%r14), %rdi
callq 0x379e
movq %rax, %rdi
callq 0x378a
movb $0x1, %bl
cmpb $0x58, %al
je 0x31ae
movq 0x10(%r14), %rdi
callq 0x379e
movq %rax, %rdi
callq 0x378a
cmpb $0x5b, %al
je 0x31ae
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::showPosition(char)
void Game::showPosition(char userDirectionInput)
{
    //replaces the current space identifier based on the direction the player
    //is going to move
    switch (userDirectionInput)
    {
        case 'w': getPlayerSpace()->getSpaceBottom()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 's': getPlayerSpace()->getSpaceUp()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 'a': getPlayerSpace()->getSpaceRight()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 'd': getPlayerSpace()->getSpaceLeft()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
    }
   
    //holds the space type identifier while the player identifier is placed
    tempSpaceType = getPlayerSpace()->getSpaceTypeIdentifier();
   
    //add the player's identifier to the map
    getPlayerSpace()->setSpaceTypeIdentifier('*');
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x61, %esi
je 0x3206
cmpl $0x64, %esi
je 0x31e2
cmpl $0x73, %esi
je 0x31f4
cmpl $0x77, %esi
jne 0x3222
movq %rbx, %rdi
callq 0x2646
movq %rax, %rdi
callq 0x3798
jmp 0x3216
movq %rbx, %rdi
callq 0x2646
movq %rax, %rdi
callq 0x379e
jmp 0x3216
movq %rbx, %rdi
callq 0x2646
movq %rax, %rdi
callq 0x3792
jmp 0x3216
movq %rbx, %rdi
callq 0x2646
movq %rax, %rdi
callq 0x37a4
movsbl 0x5(%rbx), %esi
movq %rax, %rdi
callq 0x37d0
movq %rbx, %rdi
callq 0x2646
movq %rax, %rdi
callq 0x378a
movb %al, 0x5(%rbx)
movq %rbx, %rdi
callq 0x2646
pushq $0x2a
popq %rsi
movq %rax, %rdi
popq %rbx
jmp 0x37d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::executeUserInput(char)
void Game::executeUserInput(char userInput)
{
    //switch based on the user's chosen control input
    switch(userInput)
    {
        //move up
        case 'w': makeMove(userInput);
                  break;
        //move down 
        case 's': makeMove(userInput);
                  break;
        //move left 
        case 'a': makeMove(userInput);
                  break;
        //move right 
        case 'd': makeMove(userInput);
                  break;
        //move through Portal 
        case 'e': moveThroughPortal();
                  break;
        //show contents of player's backpack
        case 'b': testSubject->displayBackpackContents();
                  break;
        //show map legend 
        case 'm': std::cout << map->getMapLegend() << std::endl;
                  break;
        //show number of turns left 
        case 't': std::cout << "You have " << turnCounter 
                            << " turns before immolation." << std::endl;
                  break;
        //show help menu 
        case 'h': std::cout << displayHelpMenu();
                  break;
        //quit game 
        case 'x': endGame(EXITED);
                  break;
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
addl $-0x61, %esi
cmpl $0x17, %esi
ja 0x34db
movq %rdi, %rbx
leaq 0x2be5(%rip), %rax      # 0x6004
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x61
jmp 0x34f3
pushq $0x64
jmp 0x34f3
movq 0x18(%rbx), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4654
movq 0x7b84(%rip), %rdi      # 0xafd0
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
jmp 0x34d3
movq 0x8(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x3e22
pushq $0x73
jmp 0x34f3
movq 0x7b56(%rip), %rdi      # 0xafd0
leaq 0x3fbc(%rip), %rsi      # 0x743d
callq 0x2190
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2270
leaq 0x3fb0(%rip), %rsi      # 0x7447
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x20e0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x324a
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2ed8
movq 0x7b05(%rip), %rdi      # 0xafd0
movq %rbx, %rsi
callq 0x2180
movq %rsp, %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbx
retq
pushq $0x3
popq %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x3516
pushq $0x77
popq %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x2f82
jmp 0x3503
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::checkForItem()
void Game::checkForItem()
{
    if (getPlayerSpace()->getItemInSpace() != NULL)
    {
        std::cout << "Oh great. You found the " << playerSpace->
            getItemInSpace()->getItemName() << "..." << std::endl << std::endl;

        //add the item to the player's backpack
        testSubject->addItemToBackpack(playerSpace->
                getItemInSpace());
       
        //remove the item from the space
        playerSpace->removeItemFromSpace();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2646
movq %rax, %rdi
callq 0x37ca
testq %rax, %rax
je 0x3602
movq 0x7a47(%rip), %rdi      # 0xafd0
leaq 0x3ed1(%rip), %rsi      # 0x7461
callq 0x2190
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x37ca
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c8a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x40c5(%rip), %rsi      # 0x7686
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movq %rsp, %rdi
callq 0x20d0
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rdi
callq 0x37ca
movq %r14, %rdi
movq %rax, %rsi
callq 0x3dd6
movq 0x10(%rbx), %rdi
callq 0x37f4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::checkForEnding()
void Game::checkForEnding()
{
    
    //executes if the player has escaped the chamber
    if (testSubject->getCurrentX() == 1 && testSubject->getCurrentY() == 4)
    {
        endGame(VICTORY);
    }

    //executes if the player dies
    if (testSubject->getHitPoints() == 0)
    {
        endGame(MELTED);
    }
     
    //executes if the player runs out of time
    if (turnCounter == 0)
    {
        endGame(BURNED);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3dbe
cmpl $0x1, %eax
jne 0x364a
movq 0x8(%rbx), %rdi
callq 0x3dc2
cmpl $0x4, %eax
jne 0x364a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3516
movq 0x8(%rbx), %rdi
callq 0x3da8
testl %eax, %eax
jne 0x3662
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3516
cmpl $0x0, (%rbx)
je 0x3669
popq %rbx
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x3516
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::playRound()
void Game::playRound()
{
    executeUserInput(getUserAction());
    checkForCake();
    checkForItem();
    checkDoor();
    checkForEnding();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x53a5
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3404
movq %rbx, %rdi
callq 0x36a0
movq %rbx, %rdi
callq 0x3560
movq %rbx, %rdi
callq 0x3676
movq %rbx, %rdi
popq %rbx
jmp 0x3620
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/space.cpp
// Function: Space::Space(char)
Space::Space(char typeIdentifier)
{
    up = bottom = left = right = NULL;
    spaceTypeIdentifier = typeIdentifier;
    itemInSpace = NULL;
    isPressed = false;
}

// Assembly:
leaq 0x7473(%rip), %rax      # 0xabc8
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movb %sil, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x9(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/button.cpp
// Function: Button::spaceTypeSpecialInteraction(Player*, Item*, Item*)
void Button::spaceTypeSpecialInteraction(Player *playerInput, Item *cc, Item *pg)
{
    //if the player has the Companion Cube, press the button down
    if (playerInput->checkBackpackForItem(cc))
    {
        isPressed = true;
        //remove the Companion Cube from the player's backpack
        playerInput->removeItemFromBackpack(cc);
        
        std::cout << "What?! How did you just open that door?!" << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3f88
testb %al, %al
je 0x39d3
movb $0x1, 0x9(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3dec
movq 0x7616(%rip), %rdi      # 0xafd0
leaq 0x3b6e(%rip), %rsi      # 0x752f
callq 0x2190
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20e0
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/player.cpp
// Function: Player::Player()
Player::Player()
{
    setHitPoints(100);
    std::cout << "It's waking up...what was it's name again?" << std::endl;
    std::cout << "Enter your name: ";
    setName(getString(false));
    setCurrentX(0);
    setCurrentY(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %r14
movb $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movl $0x64, (%rdi)
movq 0x72e6(%rip), %rdi      # 0xafd0
leaq 0x39dc(%rip), %rsi      # 0x76cd
callq 0x2190
movq %rax, %rdi
callq 0x20e0
movq 0x72cb(%rip), %rdi      # 0xafd0
leaq 0x39ec(%rip), %rsi      # 0x76f8
callq 0x2190
movq %rsp, %rdi
xorl %esi, %esi
callq 0x5114
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x20d0
andq $0x0, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rsp, %rdi
callq 0x20d0
jmp 0x3d4d
movq %rax, %r15
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x4002
movq %r14, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/JacobLCarter[P]2D-Portal/player.cpp
// Function: Player::displayBackpackContents()
void Player::displayBackpackContents()
{
    std::cout << "Current contents of your backpack: " << std::endl;

    if (backpack.empty())
    {
        std::cout << "Nothing!" << std::endl;
    }
    else
    {
        //for each item, print an ascending number and the name and description
        for (int i = 0; i < backpack.size(); i++)
        {
            std::cout << i + 1 << ": " << backpack.at(i)->getItemName()
                      << " - " << backpack.at(i)->getItemDescription()
                      << std::endl;
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x7196(%rip), %rdi      # 0xafd0
leaq 0x38c9(%rip), %rsi      # 0x770a
callq 0x2190
movq %rax, %rdi
callq 0x20e0
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
cmpq %rax, %rcx
je 0x3f39
leaq 0x30(%rbx), %r14
xorl %r15d, %r15d
leaq 0x28(%rsp), %rbp
leaq 0x8(%rsp), %r13
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x3f1e
leal 0x1(%r15), %esi
movq 0x7145(%rip), %rdi      # 0xafd0
callq 0x2270
movq %rax, %rdi
leaq 0x3a1e(%rip), %rsi      # 0x78b8
callq 0x2190
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fd6
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x3c8a
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2180
movq %rax, %rdi
leaq 0x386a(%rip), %rsi      # 0x7737
callq 0x2190
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fd6
movq (%rax), %rsi
movq %r13, %rdi
callq 0x3c98
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
movq %r13, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
incq %r15
jmp 0x3e70
movq 0x70ab(%rip), %rdi      # 0xafd0
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7090(%rip), %rdi      # 0xafd0
leaq 0x37e7(%rip), %rsi      # 0x772e
callq 0x2190
movq %rax, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x3f76
jmp 0x3f73
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280