LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::sendMsg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int tcpSocket::sendMsg(string msg, int flags){
	int bytes_sent = send(sockfd, msg.c_str(), msg.size(), flags);
	if (bytes_sent < 0)
		perror("send");
	return bytes_sent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %ecx
movl (%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x2120
movq %rax, %rbx
testl %ebx, %ebx
js 0x2c15
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2461(%rip), %rdi      # 0x507d
callq 0x21c0
jmp 0x2c0c
nop
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::recvMsg[abi:cxx11](int, int)
string tcpSocket::recvMsg(int flags, int toRead){//toRead holds the number of bytes to be read from the socket
	char buffer[toRead];
	int bytes_recv = recv(sockfd, buffer, toRead-1, flags);
	if (bytes_recv < 0){
		perror("recv");
		return "";//error
	}

	buffer[bytes_recv] = '\0';
	string str(buffer);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %eax
movq %rdi, %rbx
movl %ecx, %edx
movq %rsp, %r14
addq $0xf, %rdx
andq $-0x10, %rdx
subq %rdx, %r14
movq %r14, %rsp
movl (%rsi), %edi
decl %ecx
movslq %ecx, %rdx
movq %r14, %rsi
movl %eax, %ecx
callq 0x20f0
testl %eax, %eax
js 0x2c8c
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2110
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4964
movq %rbx, %rax
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x24e4
jmp 0x2c80
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::start()
int ftpServer::start(){
	if(socket.bind() != 0){
		return 1;
	}
	if(socket.listen() != 0){
		return 2;
	}
	printf("Successfully started on PORT: %d\n", socket.getPort());

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x2998
movl $0x1, %r14d
testl %eax, %eax
jne 0x30a2
movq %r15, %rdi
callq 0x2b60
movl $0x2, %r14d
testl %eax, %eax
jne 0x30a2
movzwl 0x30(%rbx), %esi
leaq 0x1fef(%rip), %rdi      # 0x5087
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2050
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::acceptClient()
int ftpServer::acceptClient(){
	c_socket = getSocket().accept();
	if(c_socket.getSocket() == -1){
		return 3;
	}
	printf("Successfully connected to a client (control port)\n");
	client_IP = c_socket.getOtherIp();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leaq -0x100(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0xf0(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
callq 0x48ca
leaq -0xe0(%rbp), %rdi
leaq 0x30(%rbx), %rsi
movl $0xc4, %edx
callq 0x21a0
leaq -0x1f8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x2b8e
leaq -0x1f0(%rbp), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0xf8(%rbx)
leaq 0x100(%rbx), %rdi
callq 0x22d0
leaq 0x120(%rbx), %rdi
leaq -0x1d0(%rbp), %r14
movl $0xc4, %edx
movq %r14, %rsi
callq 0x21a0
movq -0x20(%r14), %rdi
leaq -0x1e0(%rbp), %rax
cmpq %rax, %rdi
je 0x315f
callq 0x21f0
leaq 0xf8(%rbx), %r14
movq -0x100(%rbp), %rdi
cmpq %r15, %rdi
je 0x3177
callq 0x21f0
cmpl $-0x1, (%r14)
je 0x31c5
leaq 0x22ee(%rip), %rdi      # 0x5472
callq 0x2350
leaq -0x1f8(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2782
addq $0x2d8, %rbx            # imm = 0x2D8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22d0
movq (%r15), %rdi
leaq -0x1e8(%rbp), %rax
cmpq %rax, %rdi
je 0x31c1
callq 0x21f0
xorl %eax, %eax
jmp 0x31ca
movl $0x3, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x100(%rbp), %rdi
cmpq %r15, %rdi
je 0x31ec
callq 0x21f0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::allocateDataPort()
int ftpServer::allocateDataPort(){
	int new_port = atoi(recvControl(MAXBUFFSIZE).c_str());	
	if(DEBUG)
		cout << "Got port: " << new_port << endl;
	
	d_socket.setIp(client_IP);
	d_socket.setPort(new_port);
	d_socket.setHints(0);
	if(d_socket.connect() != 0)
		return 1;
	printf("Successfully connected to client again (data socket): %s\n", client_IP.c_str());
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xf8(%rdi), %rsi
leaq -0x60(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x2c24
movq (%r14), %r15
movq %r15, %rdi
callq 0x2370
movl %eax, %r14d
leaq -0x50(%rbp), %rax
cmpq %rax, %r15
je 0x323f
movq %r15, %rdi
callq 0x21f0
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x2d8(%rbx), %rsi
movq 0x2e0(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x48ca
leaq 0x1f0(%rbx), %rdi
movq %r15, %rsi
callq 0x2130
leaq 0x1e8(%rbx), %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3289
callq 0x21f0
movw %r14w, 0x210(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x218(%rbx)
movups %xmm0, 0x228(%rbx)
movups %xmm0, 0x238(%rbx)
movl $0x1, 0x220(%rbx)
movq %r15, %rdi
callq 0x280c
movl $0x1, %r14d
testl %eax, %eax
jne 0x32dd
movq 0x2d8(%rbx), %rsi
leaq 0x1dd6(%rip), %rdi      # 0x50a9
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2050
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x32fe
callq 0x21f0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::receiveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ftpServer::receiveFile(string filename){
	
	char data[MAXBUFFSIZE];
	string msgControl;
	size_t bytes_recv;
	FILE* fp = fopen(filename.c_str(), "w");

	if (fp == NULL) {
		fputs("File not found\n", stderr); 
		return 6;	
	}
    
	while ((bytes_recv = recvData(data)) > 0) {
        	fwrite(data, 1, bytes_recv, fp);
		msgControl = recvControl(4);
		if(msgControl == "EOF")
			break;
	}

	if (bytes_recv < 0) {
        	perror("recv");
	}

	fclose(fp);
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rsi), %rdi
leaq 0xf60(%rip), %rsi       # 0x52bb
callq 0x22a0
testq %rax, %rax
je 0x4429
movq %rax, %r14
movq %rbx, %r15
leaq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq -0x470(%rbp), %r12
leaq -0x70(%rbp), %r13
leaq -0x50(%rbp), %rbx
movl 0x1e8(%r15), %edi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20f0
testl %eax, %eax
je 0x43f9
movslq %eax, %rdx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x2410
movq %r13, %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x2c24
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22d0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x43e6
callq 0x21f0
movq %rbx, %rdi
leaq 0xfa3(%rip), %rsi       # 0x5393
callq 0x20b0
testl %eax, %eax
jne 0x4389
movq %r14, %rdi
callq 0x2220
xorl %ebx, %ebx
leaq -0x40(%rbp), %r15
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4415
callq 0x21f0
movl %ebx, %eax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2519
movl $0x6, %ebx
jmp 0x4407
jmp 0x4437
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x444c
callq 0x21f0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::isEmpty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ftpServer::isEmpty(string filename){
	ifstream file(filename.c_str(), ios::binary | ios::ate);
	if(!file.tellg())
		return 1;	//File is empty;
	return 0;		//File is not empty
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq (%rsi), %rsi
leaq -0x210(%rbp), %rbx
movq %rbx, %rdi
movl $0x6, %edx
callq 0x23f0
movq %rbx, %rdi
callq 0x23b0
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq -0x210(%rbp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::transferFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ftpServer::transferFile(string filename){

	FILE* fp;
	char data[MAXBUFFSIZE];
	size_t bytes_read, bytes_sent;
	long fSize, remaining;

	fp = fopen(filename.c_str(), "r");

	if (fp == NULL) {
		fputs("File not found\n", stderr); 
		return 7;	
	}

	// obtain file size:
  	fseek (fp, 0, SEEK_END);
	fSize = ftell(fp);
	rewind(fp);

	remaining = fSize;
	do {
		bytes_read = fread(data, 1, MAXBUFFSIZE-1, fp);
	
		if (bytes_read < 0) {
			fputs("Error in reading the file\n", stderr);
			return 8;
		}

		if ((bytes_sent = sendData(data, bytes_read)) < 0) {
			fputs("Error in send function\n", stderr);
			return 9;
		}
		
		if((unsigned long)remaining == bytes_sent)
			sendControl("EOF");

		else	sendControl("FSR");

		fseek(fp, bytes_sent-bytes_read, SEEK_CUR);	//As send() function may not send bytes_read amount of data
		remaining -= bytes_sent;		
		
	} while (remaining > 0);

	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movq %rdi, -0x30(%rbp)
movq (%rsi), %rdi
leaq 0xc15(%rip), %rsi       # 0x50ed
callq 0x22a0
testq %rax, %rax
je 0x4605
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2250
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, %rdi
callq 0x2060
leaq -0x48(%rbp), %r13
movl $0x1, %esi
movl $0x3ff, %edx            # imm = 0x3FF
leaq -0x480(%rbp), %r12
movq %r12, %rdi
movq %r14, %rcx
callq 0x2330
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl 0x1e8(%rax), %edi
movq %rcx, -0x38(%rbp)
movslq %ecx, %rdx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x2120
movslq %eax, %r12
subq %r12, %r15
jne 0x4586
movq %r13, -0x58(%rbp)
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
leaq 0xe30(%rip), %rsi       # 0x5393
leaq 0xe2c(%rip), %rdx       # 0x5396
callq 0x4964
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2fa0
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
jne 0x45c7
jmp 0x45cc
movq %r14, %r13
leaq -0x68(%rbp), %rbx
movq %rbx, -0x78(%rbp)
leaq -0x78(%rbp), %r14
movq %r14, %rdi
leaq 0xdf8(%rip), %rsi       # 0x5397
leaq 0xdf4(%rip), %rdx       # 0x539a
callq 0x4964
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x2fa0
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
movq %r13, %r14
leaq -0x48(%rbp), %r13
je 0x45cc
callq 0x21f0
subq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2250
testq %r15, %r15
jg 0x450f
movq %r14, %rdi
callq 0x2220
xorl %eax, %eax
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2535
movl $0x7, %eax
jmp 0x45f3
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x462b
jmp 0x4630
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x4630
callq 0x21f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::handleClients()
int ftpServer::handleClients(){
	if(start() != 0)
		return 1;

	while(1){
		if(acceptClient() != 0)
			return 2;
		if(allocateDataPort() != 0)
			return 3;

		pid_t childPID = fork();
		if(childPID == 0) {//child process
			//start waiting for the commands and send data
			while(1){
				printf("\nWaiting for request from client -- \n");
				if(sendResponse() != 0){
					cout << "Error while sending a response to client" << endl;
					break;
				}
			}
			if(DEBUG){
				printf("Terminating one of the child of server\n");
				exit(0);
			}
		} else if(childPID < 0) {//error while forking
			perror("error while forking");
			return 4;
		} else {//parent process
			continue;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3058
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x466e
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x31f4
testl %eax, %eax
jne 0x4681
callq 0x20a0
testl %eax, %eax
je 0x4688
js 0x46a1
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4657
movl $0x2, %eax
jmp 0x4652
movl $0x3, %eax
jmp 0x4652
leaq 0xe15(%rip), %r14       # 0x54a4
movq %r14, %rdi
callq 0x2350
movq %rbx, %rdi
callq 0x3306
jmp 0x468f
leaq 0xcf3(%rip), %rdi       # 0x539b
callq 0x21c0
movl $0x4, %eax
jmp 0x4652
// File: /workspace/github_cpp_makefile_star2_O1/amit-mittal[P]FTP/ftpServer.cpp
// Function: main
int main(){
	ftpServer server;
	
	cout << "*********************** \nServer Program for FTP \n***********************\n";
	cout << "Amit Mittal & Rahul Radhakrishnan, IIT Guwahati\n\n";

	if(server.handleClients() != 0){
		cout << "Error while handling clients" << endl;
		exit(1);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
leaq -0x300(%rbp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
movl $0x80, %ecx
movl %ecx, 0xd0(%r14)
leaq -0x210(%rbp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
movl %ecx, 0xd0(%r15)
leaq -0x120(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movl %ecx, 0xd0(%r12)
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movl $0x5ba0, -0x20(%r14)    # imm = 0x5BA0
movw $0x1ff6, 0x10(%r14)     # imm = 0x1FF6
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movl $0x1, %eax
movl %eax, 0x20(%r14)
movl %eax, 0x18(%r14)
movq 0x37d7(%rip), %rdi      # 0x7fd0
leaq 0xbaf(%rip), %rsi       # 0x53af
movl $0x49, %edx
callq 0x2290
movq 0x37bf(%rip), %rdi      # 0x7fd0
leaq 0xbe1(%rip), %rsi       # 0x53f9
movl $0x31, %edx
callq 0x2290
leaq -0x320(%rbp), %rdi
callq 0x4638
movq 0x379b(%rip), %rbx      # 0x7fd0
leaq 0xbef(%rip), %rsi       # 0x542b
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2290
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq 0x3769(%rip), %rdi      # 0x7fd0
callq 0x2040
movq %rax, %rdi
callq 0x2150
movl $0x1, %edi
callq 0x22b0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x488f
callq 0x21f0
movq -0x130(%rbp), %rdi
cmpq %r12, %rdi
je 0x48a0
callq 0x21f0
movq -0x220(%rbp), %rdi
cmpq %r15, %rdi
je 0x48b1
callq 0x21f0
movq -0x310(%rbp), %rdi
cmpq %r14, %rdi
je 0x48c2
callq 0x21f0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/src/i2cwrite.c
// Function: main
int main (int argc, char *argv[])
{
	int file;
	int error = 0;
	int addr = 0;
	char buf[34];

	char filename[20];

	if (argc < 5) {
		printf("Usage: i2cread [i2c device #] [i2c address] [i2c sub-address] [data]\n");
		exit(1);
	}

	snprintf(filename,19,"/dev/i2c-%d", atoi(argv[1]));
	file = open(filename, O_RDWR);
	if (file < 0) {
		printf("Error opening device\n");
		exit(1);
	}

	addr = strtol(argv[2], NULL, 16);

	if (ioctl(file, I2C_SLAVE, addr) < 0) {
		printf("Error during address set\n");
		exit(1);
	}

	buf[0] = (strtoul(argv[3], NULL, 16) >> 8) & 0xFF;
	buf[1] = strtoul(argv[3], NULL, 16) & 0xFF;
	buf[2] = strtoul(argv[4], NULL, 16) & 0xFF;

	if (write(file,buf,3) != 3) {
		printf("Error during write\n");
		exit(1);
	}

	return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x4, %edi
jle 0x1291
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x10a0
leaq 0xe24(%rip), %rdx       # 0x2004
leaq 0x30(%rsp), %r14
movl $0x13, %esi
movq %r14, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x1050
movq %r14, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
js 0x129a
movl %eax, %ebp
movq 0x10(%rbx), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1070
movl $0x703, %esi            # imm = 0x703
movl %ebp, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
js 0x12a3
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movb %ah, (%rsp)
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movq %rsp, %r14
movb %al, 0x1(%r14)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movb %al, 0x2(%r14)
movl $0x3, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1040
cmpq $0x3, %rax
jne 0x12ac
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdb9(%rip), %rdi       # 0x2051
jmp 0x12b3
leaq 0xd9b(%rip), %rdi       # 0x203c
jmp 0x12b3
leaq 0xd79(%rip), %rdi       # 0x2023
jmp 0x12b3
leaq 0xd5d(%rip), %rdi       # 0x2010
callq 0x1030
movl $0x1, %edi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: std::enable_if<!std::is_void<unsigned int>::value, unsigned int&>::type robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::operator[]<unsigned int>(unsigned int&&)
typename std::enable_if<!std::is_void<Q>::value, Q&>::type operator[](key_type&& key) {
        ROBIN_HOOD_TRACE(this)
        auto idxAndState = insertKeyPrepareEmptySpot(key);
        switch (idxAndState.second) {
        case InsertionState::key_found:
            break;

        case InsertionState::new_node:
            ::new (static_cast<void*>(&mKeyVals[idxAndState.first]))
                Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)),
                     std::forward_as_tuple());
            break;

        case InsertionState::overwrite_node:
            mKeyVals[idxAndState.first] =
                Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)),
                     std::forward_as_tuple());
            break;

        case InsertionState::overflow_error:
            throwOverflowError();
        }

        return mKeyVals[idxAndState.first].getSecond();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x173a
movq %rax, %r14
testl %edx, %edx
je 0x1720
cmpl $0x3, %edx
je 0x1713
cmpl $0x2, %edx
jne 0x1728
movq 0x8(%rbx), %rax
movl (%r15), %ecx
movl %ecx, (%rax,%r14,8)
movl $0x0, 0x4(%rax,%r14,8)
jmp 0x1728
movl (%r15), %eax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
jmp 0x1728
movq %rbx, %rdi
callq 0x187c
movq 0x8(%rbx), %rax
leaq (%rax,%r14,8), %rax
addq $0x4, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/StringTools.cpp
// Function: StringTools::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> StringTools::split(std::string s, std::string delimiter)
{
	std::vector<std::string> list;
	size_t pos = 0;
	std::string token;

	while ((pos = s.find(delimiter)) != std::string::npos)
	{
		token = s.substr(0, pos);
		if (token.length() != 0)
			list.push_back(token);
		s.erase(0, pos + delimiter.length());
	}

	list.push_back(s);

	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x32a0
cmpq $-0x1, %rax
je 0x3597
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x31d0
movq %r13, %rdi
movq %r12, %rsi
callq 0x3210
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x3571
callq 0x31a0
cmpq $0x0, -0x48(%rbp)
je 0x3584
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x366c
addq 0x8(%r15), %rbx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3060
jmp 0x352a
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x366c
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x35b5
callq 0x31a0
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35cc
jmp 0x35cc
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x35e1
callq 0x31a0
movq -0x30(%rbp), %rdi
callq 0x36b8
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/StringTools.cpp
// Function: StringTools::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string StringTools::trim(const std::string& str)
{
	size_t first = str.find_first_not_of(' ');
	if (std::string::npos == first)
	{
		return str;
	}
	size_t last = str.find_last_not_of(' ');
	return str.substr(first, (last - first + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x3190
cmpq $-0x1, %rax
je 0x3645
movq %rax, %r15
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x3140
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x31d0
jmp 0x365e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3954
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Environment.cpp
// Function: Environment::start()
void Environment::start()
{
	string input;

	// get first input
	cout << this->fs.getWorkingDirectory().getAbsolutePath() << ">";
	getline(cin, input);
	input = StringTools::trim(input);

	// loop until the input is "exit"
	while (input.compare("exit") != 0)
	{
		// handle input
		handleInput(input);

		// get next input
		cout << this->fs.getWorkingDirectory().getAbsolutePath() << ">";
		getline(cin, input);
		input = StringTools::trim(input);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rdi, -0x70(%rbp)
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0xad1a
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc078
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0xf527(%rip), %rdi      # 0x12fd0
callq 0x3200
leaq 0xa867(%rip), %rsi      # 0xe31c
movl $0x1, %edx
movq %rax, %rdi
callq 0x3200
leaq -0x38(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3ad4
callq 0x31a0
movq 0xf505(%rip), %rdi      # 0x12fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %edx
movq 0xf4ea(%rip), %r15      # 0x12fe0
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x32d0
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x35f2
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %r12
movq %r12, %rsi
callq 0x3210
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x3b2d
callq 0x31a0
leaq 0xa54c(%rip), %rsi      # 0xe080
leaq -0x68(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x3bff
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movq -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x3c6c
movq %r14, %rdi
callq 0xad1a
movq %r13, %rdi
movq %rax, %rsi
callq 0xc078
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0xf455(%rip), %rdi      # 0x12fd0
callq 0x3200
movl $0x1, %edx
movq %rax, %rdi
leaq 0xa78d(%rip), %rsi      # 0xe31c
callq 0x3200
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3ba2
callq 0x31a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x32d0
movq %r13, %rdi
movq %r12, %rsi
callq 0x35f2
movq %r12, %rdi
movq %r13, %rsi
callq 0x3210
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3be8
callq 0x31a0
movq %r12, %rdi
leaq 0xa48e(%rip), %rsi      # 0xe080
callq 0x3080
testl %eax, %eax
jne 0x3b4d
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3c11
callq 0x31a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c4f
jmp 0x3c4f
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x3c48
jmp 0x3c52
jmp 0x3c4f
jmp 0x3c4f
jmp 0x3c4f
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3c52
callq 0x31a0
jmp 0x3c52
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3c64
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Environment.cpp
// Function: Environment::operator=(Environment const&)
Environment& Environment::operator=(const Environment &env_src) {
	if (&env_src != this) {
		clean_up();
		duplicate(env_src);
	}
	if (verbose == 1 || verbose == 3)
		cout << __PRETTY_FUNCTION__ << endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x4f77
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4fd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x534e
addq $0x18, %r14
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xb13e
leaq 0xe226(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x4fca
movq 0xe041(%rip), %r14      # 0x12fd0
leaq 0x911d(%rip), %rsi      # 0xe0b3
movl $0x38, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Environment.cpp
// Function: Environment::operator=(Environment&&)
Environment& Environment::operator=(Environment &&env_src) {
	if (&env_src != this) {
		clean_up();
		steal(env_src);
	}
	if (verbose == 1 || verbose == 3)
		cout << __PRETTY_FUNCTION__ << endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x5233
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4fd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5198
leaq 0xdf6a(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x5286
movq 0xdd85(%rip), %r14      # 0x12fd0
leaq 0x8edf(%rip), %rsi      # 0xe131
movl $0x33, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Commands.cpp
// Function: CdCommand::execute(FileSystem&)
void CdCommand::execute(FileSystem& fs)
{
	std::vector<std::string> arguments = StringTools::split(this->getArgs(), " ");

	if (arguments.size() != 1 || arguments[0] == "")
	{
		std::cout << "Usage: cd <path>" << std::endl;
		return;
	}

	Directory* directory = fs.getDirectoryFromPath(arguments[0]);

	if (!directory) // enters if returned directory is nullptr, meaning not found
	{
		std::cout << "The system cannot find the path specified" << std::endl;
		return;
	}

	fs.setWorkingDirectory(directory);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0x3954
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x86d3(%rip), %rsi      # 0xe173
leaq 0x86cd(%rip), %rdx      # 0xe174
leaq -0x70(%rbp), %rdi
callq 0xabe4
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x34ec
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5ad2
callq 0x31a0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5ae3
callq 0x31a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x5b52
leaq 0x8679(%rip), %rsi      # 0xe174
callq 0x3080
testl %eax, %eax
je 0x5b52
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x3954
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xad2e
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x5b40
callq 0x31a0
testq %r14, %r14
je 0x5bac
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad24
jmp 0x5b98
movq 0xd477(%rip), %rbx      # 0x12fd0
leaq 0x8615(%rip), %rsi      # 0xe175
movl $0x10, %edx
movq %rbx, %rdi
callq 0x3200
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq 0xd445(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq -0x30(%rbp), %rdi
callq 0x36b8
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd41d(%rip), %rbx      # 0x12fd0
leaq 0x85cc(%rip), %rsi      # 0xe186
movl $0x29, %edx
movq %rbx, %rdi
callq 0x3200
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq 0xd3eb(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x5b98
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c35
callq 0x31a0
jmp 0x5c35
jmp 0x5c32
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c1f
callq 0x31a0
jmp 0x5c1f
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c3e
callq 0x31a0
jmp 0x5c3e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x36b8
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Commands.cpp
// Function: HistoryCommand::execute(FileSystem&)
void HistoryCommand::execute(FileSystem& fs)
{
	if (StringTools::trim(this->getArgs()) != "")
	{
		std::cout << "Too many arguments" << std::endl;
	}

	unsigned int counter = 0;
	for (BaseCommand* base_command : this->history)
	{
		std::cout << counter << '\t' << base_command->toString() << std::endl;
		++counter;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x3954
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x35f2
leaq 0x4665(%rip), %rsi      # 0xe174
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3080
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9b2f
callq 0x31a0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x9b3d
callq 0x31a0
testl %r14d, %r14d
je 0x9b84
movq 0x9487(%rip), %r14      # 0x12fd0
leaq 0x47f6(%rip), %rsi      # 0xe346
movl $0x12, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x48(%rbx), %rax
movq (%rax), %r13
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq %rax, %r13
je 0x9c36
xorl %r14d, %r14d
movq (%r13), %r15
movl %r14d, %esi
movq 0x9423(%rip), %rdi      # 0x12fd0
callq 0x3120
movb $0x9, -0x48(%rbp)
movl $0x1, %edx
movq %rax, %rdi
leaq -0x48(%rbp), %rbx
movq %rbx, %rsi
callq 0x3200
movq %rax, %r12
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x8(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x3200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9c25
callq 0x31a0
incl %r14d
addq $0x8, %r13
cmpq -0x50(%rbp), %r13
jne 0x9b9f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
jne 0x9c63
jmp 0x9c68
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9c68
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Commands.cpp
// Function: VerboseCommand::execute(FileSystem&)
void VerboseCommand::execute(FileSystem& fs)
{
	std::string input = StringTools::trim(this->getArgs());
	if (input == "0")
		verbose = 0;
	else if (input == "1")
		verbose = 1;
	else if (input == "2")
		verbose = 2;
	else if (input == "3")
		verbose = 3;
	else
		std::cout << "Wrong verbose input" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x3954
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x35f2
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x9f30
callq 0x31a0
leaq 0x4422(%rip), %rsi      # 0xe359
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9fcc
leaq 0x440c(%rip), %rsi      # 0xe35b
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9fd0
leaq 0x43fa(%rip), %rsi      # 0xe35d
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9fd7
leaq 0x43e8(%rip), %rsi      # 0xe35f
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9fde
movq 0x9045(%rip), %rbx      # 0x12fd0
leaq 0x43cf(%rip), %rsi      # 0xe361
movl $0x13, %edx
movq %rbx, %rdi
callq 0x3200
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq 0x9013(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x9fec
xorl %eax, %eax
jmp 0x9fe3
movl $0x1, %eax
jmp 0x9fe3
movl $0x2, %eax
jmp 0x9fe3
movl $0x3, %eax
leaq 0x91ba(%rip), %rcx      # 0x131a4
movl %eax, (%rcx)
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9ffe
callq 0x31a0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa025
jmp 0xa02a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa02a
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Commands.cpp
// Function: CommandTools::stringToCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CommandType CommandTools::stringToCommand(const std::string& input)
{
	if (input == "")
		return CommandType::EmptyCommandType;
	if (input == "pwd")
		return CommandType::PwdCommandType;
	if (input == "cd")
		return CommandType::CdCommandType;
	if (input == "ls")
		return CommandType::LsCommandType;
	if (input == "mkdir")
		return CommandType::MkdirCommandType;
	if (input == "mkfile")
		return CommandType::MkfileCommandType;
	if (input == "cp")
		return CommandType::CpCommandType;
	if (input == "mv")
		return CommandType::MvCommandType;
	if (input == "rename")
		return CommandType::RenameCommandType;
	if (input == "rm")
		return CommandType::RmCommandType;
	if (input == "history")
		return CommandType::HistoryCommandType;
	if (input == "verbose")
		return CommandType::VerboseCommandType;
	if (input == "exec")
		return CommandType::ExecCommandType;
	return CommandType::UnknownCommandType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3708(%rip), %rsi      # 0xe174
callq 0x3080
testl %eax, %eax
je 0xab8e
leaq 0x3919(%rip), %rsi      # 0xe399
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab92
leaq 0x3906(%rip), %rsi      # 0xe39d
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab99
leaq 0x38f2(%rip), %rsi      # 0xe3a0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xaba0
leaq 0x38de(%rip), %rsi      # 0xe3a3
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xaba7
leaq 0x38cd(%rip), %rsi      # 0xe3a9
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabae
leaq 0x38bd(%rip), %rsi      # 0xe3b0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabb5
leaq 0x38a9(%rip), %rsi      # 0xe3b3
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabbc
leaq 0x3895(%rip), %rsi      # 0xe3b6
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabc3
leaq 0x3885(%rip), %rsi      # 0xe3bd
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabca
leaq 0x3871(%rip), %rsi      # 0xe3c0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabd1
leaq 0x3866(%rip), %rsi      # 0xe3c8
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xabd8
leaq 0x385b(%rip), %rsi      # 0xe3d0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
movl $0xd, %ecx
movl $0x1, %eax
cmovel %ecx, %eax
jmp 0xabdd
xorl %eax, %eax
jmp 0xabdd
movl $0x2, %eax
jmp 0xabdd
movl $0x3, %eax
jmp 0xabdd
movl $0x4, %eax
jmp 0xabdd
movl $0x5, %eax
jmp 0xabdd
movl $0x6, %eax
jmp 0xabdd
movl $0x7, %eax
jmp 0xabdd
movl $0x8, %eax
jmp 0xabdd
movl $0x9, %eax
jmp 0xabdd
movl $0xa, %eax
jmp 0xabdd
movl $0xb, %eax
jmp 0xabdd
movl $0xc, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/FileSystem.cpp
// Function: FileSystem::operator=(FileSystem const&)
FileSystem &FileSystem::operator=(const FileSystem & fs_src)
{
	if (this != &fs_src)
	{
		clean_up();
		duplicate(fs_src);
	}
	if (verbose == 1 || verbose == 3)
		std::cout << __PRETTY_FUNCTION__ << std::endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xb162
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
leaq 0x803b(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb1b5
movq 0x7e56(%rip), %r14      # 0x12fd0
leaq 0x3336(%rip), %rsi      # 0xe4b7
movl $0x35, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/FileSystem.cpp
// Function: FileSystem::~FileSystem()
FileSystem::~FileSystem()
{
	delete rootDirectory;
	workingDirectory = nullptr;
	if (verbose == 1 || verbose == 3)
		std::cout << __PRETTY_FUNCTION__ << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xb1e3
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rbx)
leaq 0x7fb2(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb242
movq 0x7dcd(%rip), %rbx      # 0x12fd0
leaq 0x32e3(%rip), %rsi      # 0xe4ed
movl $0x19, %edx
movq %rbx, %rdi
callq 0x3200
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq 0x7d9b(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x3706
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/FileSystem.cpp
// Function: FileSystem::operator=(FileSystem&&)
FileSystem &FileSystem::operator=(FileSystem&& fs_src)
{
	if (this != &fs_src)
	{
		clean_up();
		steal(fs_src);
	}
	if (verbose == 1 || verbose == 3)
		std::cout << __PRETTY_FUNCTION__ << std::endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xb305
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq %rax, 0x8(%rbx)
leaq 0x7e98(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb358
movq 0x7cb3(%rip), %r14      # 0x12fd0
leaq 0x3209(%rip), %rsi      # 0xe52d
movl $0x30, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::duplicate(Directory const&)
void Directory::duplicate(const Directory& dir)
{
	this->children.clear();
	this->setName(dir.getName());
	this->setParent(dir.getParent());
	for (BaseFile* bf : dir.children)
	{
		if (Directory* d = dynamic_cast<Directory*>(bf))
		{
			Directory* new_d = new Directory(*d);
			new_d->setParent(this);
			this->children.push_back(new_d);
		}
		else if (File* f = dynamic_cast<File*>(bf))
		{
			File* new_f = new File(*f);
			this->children.push_back(new_f);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0xb68d
movq %rax, 0x30(%rbx)
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3954
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3100
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0xb6c7
callq 0x31a0
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movq 0x28(%r14), %r12
movq 0x30(%r14), %r14
cmpq %r14, %r12
je 0xb7ef
leaq 0x28(%rbx), %rax
movq %rax, -0x38(%rbp)
movq (%r12), %r15
testq %r15, %r15
je 0xb70e
movq %r15, %rdi
leaq 0x7675(%rip), %rsi      # 0x12d70
leaq 0x767e(%rip), %rdx      # 0x12d80
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r13
jmp 0xb711
xorl %r13d, %r13d
testq %r13, %r13
je 0xb74c
movl $0x48, %edi
callq 0x31c0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xb528
movq %rbx, 0x40(%r15)
movq %r15, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xb7d5
movq %r15, (%rsi)
jmp 0xb7ce
testq %r15, %r15
je 0xb76e
movq %r15, %rdi
leaq 0x7615(%rip), %rsi      # 0x12d70
leaq 0x7636(%rip), %rdx      # 0x12d98
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0xb771
xorl %r15d, %r15d
testq %r15, %r15
je 0xb7e2
movl $0x30, %edi
callq 0x31c0
movq %rax, %r13
leaq 0x757e(%rip), %rax      # 0x12d08
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
movq %rax, 0x8(%r13)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x3954
leaq 0x757f(%rip), %rax      # 0x12d30
movq %rax, (%r13)
movl 0x28(%r15), %eax
movl %eax, 0x28(%r13)
movq %r13, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xb7d5
movq %r13, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xb7e2
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xd270
addq $0x8, %r12
cmpq %r14, %r12
jne 0xb6e8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
jne 0xb81a
jmp 0xb81f
movq %rax, %rbx
movq %r13, %rdi
jmp 0xb81a
movq %rax, %rbx
movq %r15, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::operator=(Directory const&)
Directory& Directory::operator=(const Directory& dir)
{
	if (this != & dir)
	{
		clean_up();
		duplicate(dir);
	}
	if (verbose == 1 || verbose == 3)
		std::cout << __PRETTY_FUNCTION__ << std::endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xb84d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb8a8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb668
leaq 0x7950(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb8a0
movq 0x776b(%rip), %r14      # 0x12fd0
leaq 0x2d1a(%rip), %rsi      # 0xe586
movl $0x32, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::clean_up()
void Directory::clean_up()
{
	std::vector<BaseFile*>::iterator iterator = this->children.begin();
	while (!this->children.empty() && iterator != this->children.end())
	{
		this->removeFile(*iterator);
	}
	this->children.clear();
	this->parent = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
cmpq 0x30(%rdi), %r14
je 0xb8e2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xbf04
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0xb8e2
cmpq %rcx, %r14
jne 0xb8bc
cmpq %rcx, %rax
je 0xb8e2
movq %rax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::steal(Directory&)
void Directory::steal(Directory& dir)
{
	this->setName(dir.getName());
	this->parent = dir.parent;
	dir.parent = NULL;
	for (BaseFile* bf : dir.children)
	{
		this->children.push_back(bf);
		if (Directory* d = dynamic_cast<Directory*>(bf))
			d->setParent(this);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x3954
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3100
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xbb49
callq 0x31a0
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movq $0x0, 0x40(%r14)
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
cmpq %r12, %r15
je 0xbbc8
leaq 0x28(%rbx), %r14
leaq 0x720f(%rip), %r13      # 0x12d80
movq (%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xbb8c
movq %rax, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xbb98
movq %r14, %rdi
leaq -0x30(%rbp), %rdx
callq 0xc626
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xbbb4
leaq 0x71c8(%rip), %rsi      # 0x12d70
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x31f0
jmp 0xbbb6
xorl %eax, %eax
testq %rax, %rax
je 0xbbbf
movq %rbx, 0x40(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0xbb71
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xbbe8
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::operator=(Directory&&)
Directory& Directory::operator=(Directory && dir) 
{
	if (this != &dir)
	{
		clean_up();
		steal(dir);
	}
	if (verbose == 1 || verbose == 3)
		std::cout << __PRETTY_FUNCTION__ << std::endl;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xbc15
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb8a8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbaf8
leaq 0x7588(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xbc68
movq 0x73a3(%rip), %r14      # 0x12fd0
leaq 0x29c8(%rip), %rsi      # 0xe5fc
movl $0x2d, %edx
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq