LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::transferMaxToCache()
void transferMaxToCache(){
        T output;
        while (slowDequeue(output)){
            if (!fastEnqueue(output)){
                slowEnqueue(output);
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xacc0
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb140
movb %al, -0x41(%rbp)
jmp 0xd7cf
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xd7d8
jmp 0xd81d
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa510
movb %al, -0x42(%rbp)
jmp 0xd7ea
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xd81b
jmp 0xd7f3
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa640
jmp 0xd802
jmp 0xd81d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa2a0
jmp 0xd82c
jmp 0xd7bd
leaq -0x28(%rbp), %rdi
callq 0xa2a0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xaf80
nopw %cs:(%rax,%rax)
nop
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<int, 16ul>::slowDequeue(int&)
inline bool slowDequeue(T &output){
        listNode* tail = _tail.load(std::memory_order_relaxed);
        listNode* next = tail->next.load(std::memory_order_acquire);
        if (next == nullptr) return false;

        output = next->data;
        _tail.store(next, std::memory_order_release);
        delete tail;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x198, %rdi            # imm = 0x198
xorl %esi, %esi
callq 0xa6c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0x2, %esi
callq 0xa6c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe88d
movb $0x0, -0x1(%rbp)
jmp 0xe8d2
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x198, %rdi            # imm = 0x198
movq -0x28(%rbp), %rsi
movl $0x3, %edx
callq 0xad80
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xe8ce
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0xa870
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<int, 16ul>::fastEnqueue(int const&)
bool fastEnqueue(const T& input){
        if (_cache.enqueue(input)){    
            if (waitingReader.load(std::memory_order_acquire)) _cv.notify_one();
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0xa420
testb $0x1, %al
jne 0xf417
jmp 0xf448
movq -0x20(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movl $0x2, %esi
callq 0xae90
testb $0x1, %al
jne 0xf432
jmp 0xf442
movq -0x20(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0xa380
movb $0x1, -0x1(%rbp)
jmp 0xf44c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<int, 16ul>::slowEnqueue(int const&)
inline void slowEnqueue(const T& input){
        listNode* node = new listNode();
        node->data = input;
        listNode* prev_head = _head.exchange(node, std::memory_order_acq_rel);
        prev_head->next.store(node, std::memory_order_release);

        if (waitingReader.load(std::memory_order_acquire)) _cv.notify_one();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0xa820
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0xa410
movq -0x30(%rbp), %rdi
callq 0xabf0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x190, %rdi            # imm = 0x190
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0xaad0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0xad80
movq -0x28(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movl $0x2, %esi
callq 0xae90
testb $0x1, %al
jne 0xf500
jmp 0xf510
movq -0x28(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0xa380
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::setHints(int)
void tcpSocket::setHints(int flag){
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	if(flag == 1)//server
		hints.ai_flags = AI_PASSIVE; // use my IP
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2130
movq -0x18(%rbp), %rax
movl $0x0, 0x34(%rax)
movl $0x1, 0x38(%rax)
cmpl $0x1, -0xc(%rbp)
jne 0x276a
movq -0x18(%rbp), %rax
movl $0x1, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::getOtherIp[abi:cxx11]()
string tcpSocket::getOtherIp(){

	socklen_t len;
	struct sockaddr_storage addr;
	char ipstr[INET6_ADDRSTRLEN];

	len = sizeof addr;
	getpeername(getSocket(), (struct sockaddr*)&addr, &len);

	// deal with both IPv4 and IPv6:
	if (addr.ss_family == AF_INET) {
    		struct sockaddr_in *s = (struct sockaddr_in *)&addr;
    		inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);
	} else { // AF_INET6
   		 struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
    		inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);
	}

	string str(ipstr);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x80, -0x14(%rbp)
callq 0x26c0
movl %eax, %edi
leaq -0x98(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2180
movzwl -0x98(%rbp), %eax
cmpl $0x2, %eax
jne 0x27f3
leaq -0x98(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rsi
addq $0x4, %rsi
leaq -0xd0(%rbp), %rdx
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x2240
jmp 0x2822
leaq -0x98(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rsi
addq $0x8, %rsi
leaq -0xd0(%rbp), %rdx
movl $0xa, %edi
movl $0x2e, %ecx
callq 0x2240
movb $0x0, -0xe1(%rbp)
leaq -0xe2(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x23d0
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rdx
leaq -0xd0(%rbp), %rsi
callq 0x22f0
jmp 0x2858
leaq -0xe2(%rbp), %rdi
callq 0x2250
movb $0x1, -0xe1(%rbp)
testb $0x1, -0xe1(%rbp)
jne 0x28a2
jmp 0x2896
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xe2(%rbp), %rdi
callq 0x2250
jmp 0x28b2
movq -0x108(%rbp), %rdi
callq 0x2150
movq -0x100(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x23c0
nop
// File: amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::listen()
int tcpSocket::listen(){
	if (::listen(sockfd, BACKLOG) == -1) {
		perror("listen");
		return 1;
	}
	return 0;//no error
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0xa, %esi
callq 0x2280
cmpl $-0x1, %eax
jne 0x2e36
leaq 0x3247(%rip), %rdi      # 0x606f
callq 0x21c0
movl $0x1, -0x4(%rbp)
jmp 0x2e3d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amit-mittal[P]FTP/./include/../tcpSocket.cpp
// Function: tcpSocket::accept()
tcpSocket tcpSocket::accept(){
	int newfd = ::accept(sockfd, (struct sockaddr *)&their_addr, &their_addr_size);
	if(newfd == -1)
		perror("accept");
	return tcpSocket(newfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movl (%rdx), %edi
movq %rdx, %rsi
addq $0x68, %rsi
addq $0xe8, %rdx
callq 0x20d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2e99
leaq 0x31e2(%rip), %rdi      # 0x6076
callq 0x21c0
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2600
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x2160
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
callq 0x2120
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x2f14
leaq 0x316e(%rip), %rdi      # 0x607d
callq 0x21c0
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rsp, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rsi
subq %rdx, %rsi
movq %rsi, -0x50(%rbp)
movq %rsi, %rsp
movq %rcx, -0x28(%rbp)
movl (%rax), %edi
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
movl -0x14(%rbp), %ecx
callq 0x20e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x2fe2
leaq 0x30f4(%rip), %rdi      # 0x6082
callq 0x21c0
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x23d0
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x3560(%rip), %rsi      # 0x650f
callq 0x22f0
jmp 0x2fb6
leaq -0x2d(%rbp), %rdi
callq 0x2250
movl $0x1, -0x40(%rbp)
jmp 0x3050
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x2250
jmp 0x3060
movq -0x50(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, -0x41(%rbp)
leaq -0x42(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x23d0
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x22f0
jmp 0x3012
leaq -0x42(%rbp), %rdi
callq 0x2250
movb $0x1, -0x41(%rbp)
movl $0x1, -0x40(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x304e
jmp 0x3045
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x42(%rbp), %rdi
callq 0x2250
jmp 0x3060
movq -0x60(%rbp), %rdi
callq 0x2150
jmp 0x3050
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x23c0
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x2b60
cmpl $0x0, %eax
je 0x347b
movl $0x1, -0x4(%rbp)
jmp 0x34bb
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e00
cmpl $0x0, %eax
je 0x3496
movl $0x2, -0x4(%rbp)
jmp 0x34bb
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2670
movzwl %ax, %esi
leaq 0x2bda(%rip), %rdi      # 0x6087
movb $0x0, %al
callq 0x2050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x230(%rbp)
leaq -0x1f0(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x3150
movq -0x228(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x2e50
jmp 0x3512
movq -0x230(%rbp), %rdi
addq $0xf8, %rdi
leaq -0x100(%rbp), %rsi
callq 0x5c30
leaq -0x100(%rbp), %rdi
callq 0x5b50
leaq -0x1f0(%rbp), %rdi
callq 0x5b50
movq -0x230(%rbp), %rdi
addq $0xf8, %rdi
callq 0x26c0
cmpl $-0x1, %eax
jne 0x3585
movl $0x3, -0x4(%rbp)
jmp 0x35da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f8(%rbp)
movl %eax, -0x1fc(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x5b50
jmp 0x35e6
leaq 0x2b1d(%rip), %rdi      # 0x60a9
movb $0x0, %al
callq 0x2050
movq -0x230(%rbp), %rsi
addq $0xf8, %rsi
leaq -0x220(%rbp), %rdi
callq 0x2770
movq -0x230(%rbp), %rdi
addq $0x2d8, %rdi            # imm = 0x2D8
leaq -0x220(%rbp), %rsi
callq 0x22c0
leaq -0x220(%rbp), %rdi
callq 0x2150
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x1f8(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x400, %edx            # imm = 0x400
callq 0x33b0
movq -0x90(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2370
movq -0x90(%rbp), %rdi
movl %eax, -0x84(%rbp)
callq 0x2150
movl -0x84(%rbp), %eax
movq -0x80(%rbp), %rsi
movl %eax, -0x14(%rbp)
movq %rsi, %rax
addq $0x1e8, %rax            # imm = 0x1E8
movq %rax, -0x78(%rbp)
addq $0x2d8, %rsi            # imm = 0x2D8
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2100
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x26d0
jmp 0x368f
leaq -0x58(%rbp), %rdi
callq 0x2150
movq -0x80(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movl -0x14(%rbp), %eax
movzwl %ax, %esi
callq 0x2700
movq -0x80(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
xorl %esi, %esi
callq 0x2720
movq -0x80(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x28c0
cmpl $0x0, %eax
je 0x36f5
movl $0x1, -0x4(%rbp)
jmp 0x371d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2150
jmp 0x3729
movq -0x80(%rbp), %rdi
addq $0x2d8, %rdi            # imm = 0x2D8
callq 0x20f0
movq %rax, %rsi
leaq 0x29cd(%rip), %rdi      # 0x60dc
movb $0x0, %al
callq 0x2050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: amit-mittal[P]FTP/ftpServer.cpp
// Function: ftpServer::fileExists(char const*)
int ftpServer::fileExists(const char* filename){

	struct stat buffer;
	if (stat(filename, &buffer) != -1)
		return 1;	//File exists
	return 0;		//File does not exist
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x21e0
cmpl $-0x1, %eax
je 0x5291
movl $0x1, -0x4(%rbp)
jmp 0x5298
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x4b0, %rsp            # imm = 0x4B0
movq %rsi, -0x490(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x498(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2300
movq -0x490(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0xff7(%rip), %rsi       # 0x62ee
callq 0x2290
movq %rax, -0x488(%rbp)
jmp 0x5305
movq -0x488(%rbp), %rax
movq %rax, -0x450(%rbp)
cmpq $0x0, -0x450(%rbp)
jne 0x536e
movq 0x3cb4(%rip), %rax      # 0x8fd8
movq (%rax), %rsi
leaq 0x10b8(%rip), %rdi      # 0x63e6
callq 0x2270
jmp 0x5335
movl $0x6, -0x4(%rbp)
movl $0x1, -0x460(%rbp)
jmp 0x5473
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x458(%rbp)
movl %eax, -0x45c(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2150
jmp 0x548b
jmp 0x5370
movq -0x498(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x3410
movl %eax, -0x49c(%rbp)
jmp 0x538b
movl -0x49c(%rbp), %eax
cltq
movq %rax, -0x448(%rbp)
cmpq $0x0, %rax
jbe 0x543a
movq -0x448(%rbp), %rdx
movq -0x450(%rbp), %rcx
leaq -0x420(%rbp), %rdi
movl $0x1, %esi
callq 0x2410
jmp 0x53c5
movq -0x498(%rbp), %rsi
leaq -0x480(%rbp), %rdi
movl $0x4, %edx
callq 0x33b0
jmp 0x53df
leaq -0x440(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
leaq -0x480(%rbp), %rsi
movq %rsi, -0x4b0(%rbp)
callq 0x22c0
movq -0x4b0(%rbp), %rdi
callq 0x2150
movq -0x4a8(%rbp), %rdi
leaq 0xfdc(%rip), %rsi       # 0x63f6
callq 0x5c90
movb %al, -0x49d(%rbp)
jmp 0x5427
movb -0x49d(%rbp), %al
testb $0x1, %al
jne 0x5433
jmp 0x5435
jmp 0x543a
jmp 0x5370
cmpq $0x0, -0x448(%rbp)
jae 0x5454
leaq 0xc37(%rip), %rdi       # 0x6082
callq 0x21c0
jmp 0x5452
jmp 0x5454
movq -0x450(%rbp), %rdi
callq 0x2210
jmp 0x5462
movl $0x0, -0x4(%rbp)
movl $0x1, -0x460(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2150
movl -0x4(%rbp), %eax
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
movq -0x458(%rbp), %rdi
callq 0x23c0
nopw (%rax,%rax)
// File: 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
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x268(%rbp)
movq %rdi, %rax
movq -0x268(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x20f0
movq %rax, -0x260(%rbp)
movl $0x4, %edi
movl $0x2, %esi
callq 0x5cc0
movq -0x260(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x23f0
movq -0x258(%rbp), %rdi
callq 0x23b0
movq %rdx, -0x250(%rbp)
movq %rax, -0x248(%rbp)
jmp 0x5517
movq -0x250(%rbp), %rax
movq -0x248(%rbp), %rcx
movq %rcx, -0x230(%rbp)
movq %rax, -0x228(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x5ce0
movq %rax, -0x270(%rbp)
jmp 0x5548
movq -0x270(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x555e
jmp 0x5591
movl $0x1, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
jmp 0x55a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x2090
jmp 0x55ba
movl $0x0, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x2090
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3450
cmpl $0x0, %eax
je 0x590a
movl $0x1, -0x4(%rbp)
jmp 0x59b6
jmp 0x590c
movq -0x20(%rbp), %rdi
callq 0x34d0
cmpl $0x0, %eax
je 0x5926
movl $0x2, -0x4(%rbp)
jmp 0x59b6
movq -0x20(%rbp), %rdi
callq 0x3600
cmpl $0x0, %eax
je 0x593d
movl $0x3, -0x4(%rbp)
jmp 0x59b6
callq 0x20a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5991
jmp 0x594d
leaq 0xadd(%rip), %rdi       # 0x6431
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
callq 0x3740
cmpl $0x0, %eax
je 0x598d
movq 0x3660(%rip), %rdi      # 0x8fd0
leaq 0xae0(%rip), %rsi       # 0x6457
callq 0x2200
movq %rax, %rdi
movq 0x363a(%rip), %rsi      # 0x8fc0
callq 0x2230
jmp 0x598f
jmp 0x594d
jmp 0x59b1
cmpl $0x0, -0x14(%rbp)
jge 0x59ac
leaq 0xae2(%rip), %rdi       # 0x6480
callq 0x21c0
movl $0x4, -0x4(%rbp)
jmp 0x59b6
jmp 0x590c
jmp 0x590c
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x320, %rsp            # imm = 0x320
movl $0x0, -0x4(%rbp)
leaq -0x300(%rbp), %rdi
callq 0x3070
movq 0x354b(%rip), %rdi      # 0x8fd0
leaq 0xa08(%rip), %rsi       # 0x6494
callq 0x2200
jmp 0x5a93
movq 0x3536(%rip), %rdi      # 0x8fd0
leaq 0xa3d(%rip), %rsi       # 0x64de
callq 0x2200
jmp 0x5aa8
leaq -0x300(%rbp), %rdi
callq 0x58e0
movl %eax, -0x310(%rbp)
jmp 0x5abc
movl -0x310(%rbp), %eax
cmpl $0x0, %eax
je 0x5b22
movq 0x3502(%rip), %rdi      # 0x8fd0
leaq 0xa3b(%rip), %rsi       # 0x6510
callq 0x2200
movq %rax, -0x318(%rbp)
jmp 0x5ae3
movq -0x318(%rbp), %rdi
movq 0x34cf(%rip), %rsi      # 0x8fc0
callq 0x2230
jmp 0x5af8
movl $0x1, %edi
callq 0x22a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x308(%rbp)
movl %eax, -0x30c(%rbp)
leaq -0x300(%rbp), %rdi
callq 0x5d00
jmp 0x5b41
movl $0x0, -0x4(%rbp)
leaq -0x300(%rbp), %rdi
callq 0x5d00
movl -0x4(%rbp), %eax
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
movq -0x308(%rbp), %rdi
callq 0x23c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x1202
leaq 0xe13(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10b0
leaq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movq -0x68(%rbp), %rdi
movl %eax, %ecx
movl $0x13, %esi
leaq 0xe21(%rip), %rdx       # 0x204a
movb $0x0, %al
callq 0x1050
leaq -0x60(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x1080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1261
leaq 0xe06(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x1070
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x1060
cmpl $0x0, %eax
jge 0x12a9
leaq 0xdd4(%rip), %rdi       # 0x206c
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x1090
shrq $0x8, %rax
andq $0xff, %rax
movb %al, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x1090
andq $0xff, %rax
movb %al, -0x3f(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x1090
andq $0xff, %rax
movb %al, -0x3e(%rbp)
movl -0x14(%rbp), %edi
leaq -0x40(%rbp), %rsi
movl $0x3, %edx
callq 0x1030
cmpq $0x3, %rax
je 0x1339
leaq 0xd5e(%rip), %rdi       # 0x2086
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10b0
movl -0x18(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x68(%rsp), %rsi
callq 0x19d0
movl %edx, 0x50(%rsp)
movq %rax, 0x48(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0x60(%rsp), %eax
movq %rax, 0x18(%rsp)
subq $0x3, %rax
ja 0x18d1
movq 0x18(%rsp), %rax
leaq 0x1804(%rip), %rcx      # 0x3020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x18d1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x1d10
callq 0x1d40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x1857(%rip), %rdx      # 0x30c0
leaq 0x40(%rsp), %rcx
leaq 0x3f(%rsp), %r8
callq 0x1d50
jmp 0x18d1
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1d10
callq 0x1d40
movq 0x10(%rsp), %rsi
leaq 0x34(%rsp), %rdi
leaq 0x1821(%rip), %rdx      # 0x30c0
leaq 0x28(%rsp), %rcx
leaq 0x27(%rsp), %r8
callq 0x1d50
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rsp), %rcx
movq 0x34(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x18d1
movq 0x10(%rsp), %rdi
callq 0x1da0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1e10
addq $0x78, %rsp
retq
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3750
movq $0x0, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3270
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3340
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0x3670
movq -0x90(%rbp), %rsi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x31d0
jmp 0x35dc
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3230
leaq -0x68(%rbp), %rdi
callq 0x3130
leaq -0x48(%rbp), %rdi
callq 0x32a0
cmpq $0x0, %rax
je 0x3638
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3770
jmp 0x3613
jmp 0x3638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3130
movq -0x88(%rbp), %rdi
callq 0x37e0
jmp 0x36b1
movq -0x98(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x32a0
movq -0xa0(%rbp), %rdx
movq -0x90(%rbp), %rdi
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3080
jmp 0x366b
jmp 0x359d
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x3770
jmp 0x3685
movb $0x1, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3130
testb $0x1, -0x19(%rbp)
jne 0x36a4
movq -0x88(%rbp), %rdi
callq 0x37e0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3300
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3190
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq -0x18(%rbp), %rax
jne 0x370d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30e0
jmp 0x3743
movq -0x10(%rbp), %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x3140
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
addq $0x1, %rcx
callq 0x31d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3270
movq -0xc8(%rbp), %rdi
addq $0x18, %rdi
callq 0xe1b0
movq %rax, -0xc0(%rbp)
jmp 0x44ec
movq -0xc0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xfa90
jmp 0x44fe
movq 0x17ac3(%rip), %rdi     # 0x1bfc8
leaq -0x48(%rbp), %rsi
callq 0x3180
movq %rax, -0xd0(%rbp)
jmp 0x4517
movq -0xd0(%rbp), %rdi
leaq 0xfdcf(%rip), %rsi      # 0x142f4
callq 0x31b0
jmp 0x452c
leaq -0x48(%rbp), %rdi
callq 0x3130
movq 0x17aa4(%rip), %rdi     # 0x1bfe0
leaq -0x28(%rbp), %rsi
callq 0x3070
jmp 0x4547
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36c0
jmp 0x4556
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3230
leaq -0x78(%rbp), %rdi
callq 0x3130
leaq -0x28(%rbp), %rdi
leaq 0xfae1(%rip), %rsi      # 0x14058
callq 0x30a0
cmpl $0x0, %eax
je 0x4686
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x46b0
jmp 0x4597
movq -0xc8(%rbp), %rdi
addq $0x18, %rdi
callq 0xe1b0
movq %rax, -0xd8(%rbp)
jmp 0x45b0
movq -0xd8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xfa90
jmp 0x45c5
movq 0x179fc(%rip), %rdi     # 0x1bfc8
leaq -0x98(%rbp), %rsi
callq 0x3180
movq %rax, -0xe0(%rbp)
jmp 0x45e1
movq -0xe0(%rbp), %rdi
leaq 0xfd05(%rip), %rsi      # 0x142f4
callq 0x31b0
jmp 0x45f6
leaq -0x98(%rbp), %rdi
callq 0x3130
movq 0x179d7(%rip), %rdi     # 0x1bfe0
leaq -0x28(%rbp), %rsi
callq 0x3070
jmp 0x4614
leaq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36c0
jmp 0x4626
leaq -0x28(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3230
leaq -0xb8(%rbp), %rdi
callq 0x3130
jmp 0x456c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3130
jmp 0x4698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3130
jmp 0x4698
leaq -0x28(%rbp), %rdi
callq 0x3130
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x3130
movq -0x50(%rbp), %rdi
callq 0x3300
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x5934
movq -0x18(%rbp), %rdi
callq 0x5980
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58c0
leaq 0x16899(%rip), %rax     # 0x1c1d4
cmpl $0x1, (%rax)
je 0x594c
leaq 0x1688d(%rip), %rax     # 0x1c1d4
cmpl $0x3, (%rax)
jne 0x596e
movq 0x16675(%rip), %rdi     # 0x1bfc8
leaq 0xe731(%rip), %rsi      # 0x1408b
callq 0x31b0
movq %rax, %rdi
movq 0x1664f(%rip), %rsi     # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x5c64
movq -0x18(%rbp), %rdi
callq 0x5980
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5b90
leaq 0x16569(%rip), %rax     # 0x1c1d4
cmpl $0x1, (%rax)
je 0x5c7c
leaq 0x1655d(%rip), %rax     # 0x1c1d4
cmpl $0x3, (%rax)
jne 0x5c9e
movq 0x16345(%rip), %rdi     # 0x1bfc8
leaq 0xe47f(%rip), %rsi      # 0x14109
callq 0x31b0
movq %rax, %rdi
movq 0x1631f(%rip), %rsi     # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7c70
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3310
movq -0xb0(%rbp), %rdx
leaq 0xc18d(%rip), %rsi      # 0x1414b
leaq -0x68(%rbp), %rdi
callq 0x3260
jmp 0x7fc9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x3550
jmp 0x7fdc
leaq -0x68(%rbp), %rdi
callq 0x3130
leaq -0x69(%rbp), %rdi
callq 0x3200
leaq -0x48(%rbp), %rdi
callq 0x3130
leaq -0x28(%rbp), %rdi
callq 0x4020
cmpq $0x1, %rax
jne 0x8039
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xd9b0
movq %rax, %rdi
leaq 0xc12f(%rip), %rsi      # 0x1414c
callq 0xd980
movb %al, -0xb1(%rbp)
jmp 0x802a
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x8039
jmp 0x80c1
movq 0x13f88(%rip), %rdi     # 0x1bfc8
leaq 0xc106(%rip), %rsi      # 0x1414d
callq 0x31b0
movq %rax, -0xc0(%rbp)
jmp 0x8055
movq -0xc0(%rbp), %rdi
movq 0x13f55(%rip), %rsi     # 0x1bfb8
callq 0x31e0
jmp 0x806a
movl $0x1, -0x80(%rbp)
jmp 0x8197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x8099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3130
leaq -0x69(%rbp), %rdi
callq 0x3200
leaq -0x48(%rbp), %rdi
callq 0x3130
jmp 0x81b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x81a9
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xd9b0
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x30e0
jmp 0x80ea
movq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xe1f0
movq %rax, -0xd0(%rbp)
jmp 0x8106
leaq -0xa8(%rbp), %rdi
callq 0x3130
movq -0xd0(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x817e
movq 0x13e97(%rip), %rdi     # 0x1bfc8
leaq 0xc026(%rip), %rsi      # 0x1415e
callq 0x31b0
movq %rax, -0xd8(%rbp)
jmp 0x8146
movq -0xd8(%rbp), %rdi
movq 0x13e64(%rip), %rsi     # 0x1bfb8
callq 0x31e0
jmp 0x815b
movl $0x1, -0x80(%rbp)
jmp 0x8197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3130
jmp 0x81a9
movq -0x10(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xe1d0
jmp 0x8190
movl $0x0, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x37e0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x37e0
movq -0x78(%rbp), %rdi
callq 0x3300
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x7c70
movq -0xa8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x36c0
jmp 0xc900
leaq 0x7845(%rip), %rsi      # 0x1414c
leaq -0x30(%rbp), %rdi
callq 0xd9d0
movb %al, -0xb1(%rbp)
jmp 0xc918
leaq -0x30(%rbp), %rdi
callq 0x3130
leaq -0x50(%rbp), %rdi
callq 0x3130
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xc936
jmp 0xc98b
movq 0xf68b(%rip), %rdi      # 0x1bfc8
leaq 0x79da(%rip), %rsi      # 0x1431e
callq 0x31b0
movq %rax, %rdi
movq 0xf665(%rip), %rsi      # 0x1bfb8
callq 0x31e0
jmp 0xc98b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xc97d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
leaq -0x50(%rbp), %rdi
callq 0x3130
jmp 0xca96
movq -0xb0(%rbp), %rax
movl $0x0, -0x60(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x6720
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x6750
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6780
testb $0x1, %al
jne 0xc9d1
jmp 0xca8d
leaq -0x70(%rbp), %rdi
callq 0x67c0
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movl -0x60(%rbp), %esi
movq 0xf5dd(%rip), %rdi      # 0x1bfc8
callq 0x3250
movq %rax, %rdi
movl $0x9, %esi
callq 0x3220
movq %rax, -0xd0(%rbp)
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq *%rax
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x3180
movq %rax, -0xc0(%rbp)
jmp 0xca3b
movq -0xc0(%rbp), %rdi
movq 0xf56f(%rip), %rsi      # 0x1bfb8
callq 0x31e0
jmp 0xca50
leaq -0xa0(%rbp), %rdi
callq 0x3130
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x67e0
jmp 0xc9bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3130
jmp 0xca96
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3300
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7c70
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x36c0
jmp 0xccc3
leaq -0x50(%rbp), %rdi
callq 0x3130
leaq 0x765e(%rip), %rsi      # 0x14331
leaq -0x30(%rbp), %rdi
callq 0xd980
movb %al, -0x69(%rbp)
jmp 0xcce1
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xccea
jmp 0xcd30
leaq 0xf4e3(%rip), %rax      # 0x1c1d4
movl $0x0, (%rax)
jmp 0xcded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3130
jmp 0xcdff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
jmp 0xcdff
leaq 0x75fc(%rip), %rsi      # 0x14333
leaq -0x30(%rbp), %rdi
callq 0xd980
movb %al, -0x6a(%rbp)
jmp 0xcd45
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0xcd4e
jmp 0xcd60
leaq 0xf47f(%rip), %rax      # 0x1c1d4
movl $0x1, (%rax)
jmp 0xcdeb
leaq 0x75ce(%rip), %rsi      # 0x14335
leaq -0x30(%rbp), %rdi
callq 0xd980
movb %al, -0x6b(%rbp)
jmp 0xcd75
movb -0x6b(%rbp), %al
testb $0x1, %al
jne 0xcd7e
jmp 0xcd8d
leaq 0xf44f(%rip), %rax      # 0x1c1d4
movl $0x2, (%rax)
jmp 0xcde9
leaq 0x75a3(%rip), %rsi      # 0x14337
leaq -0x30(%rbp), %rdi
callq 0xd980
movb %al, -0x6c(%rbp)
jmp 0xcda2
movb -0x6c(%rbp), %al
testb $0x1, %al
jne 0xcdab
jmp 0xcdba
leaq 0xf422(%rip), %rax      # 0x1c1d4
movl $0x3, (%rax)
jmp 0xcde7
movq 0xf207(%rip), %rdi      # 0x1bfc8
leaq 0x7571(%rip), %rsi      # 0x14339
callq 0x31b0
movq %rax, -0x78(%rbp)
jmp 0xcdd3
movq -0x78(%rbp), %rdi
movq 0xf1da(%rip), %rsi      # 0x1bfb8
callq 0x31e0
jmp 0xcde5
jmp 0xcde7
jmp 0xcde9
jmp 0xcdeb
jmp 0xcded
leaq -0x30(%rbp), %rdi
callq 0x3130
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3300
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6a55(%rip), %rsi      # 0x1414c
callq 0xd980
testb $0x1, %al
jne 0xd702
jmp 0xd70e
movl $0x0, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6c58(%rip), %rsi      # 0x14371
callq 0xd980
testb $0x1, %al
jne 0xd724
jmp 0xd730
movl $0x2, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6c3a(%rip), %rsi      # 0x14375
callq 0xd980
testb $0x1, %al
jne 0xd746
jmp 0xd752
movl $0x3, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6c1b(%rip), %rsi      # 0x14378
callq 0xd980
testb $0x1, %al
jne 0xd768
jmp 0xd774
movl $0x4, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6bfc(%rip), %rsi      # 0x1437b
callq 0xd980
testb $0x1, %al
jne 0xd78a
jmp 0xd796
movl $0x5, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6be0(%rip), %rsi      # 0x14381
callq 0xd980
testb $0x1, %al
jne 0xd7ac
jmp 0xd7b8
movl $0x6, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6bc5(%rip), %rsi      # 0x14388
callq 0xd980
testb $0x1, %al
jne 0xd7ce
jmp 0xd7da
movl $0x7, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6ba6(%rip), %rsi      # 0x1438b
callq 0xd980
testb $0x1, %al
jne 0xd7f0
jmp 0xd7fc
movl $0x8, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6b87(%rip), %rsi      # 0x1438e
callq 0xd980
testb $0x1, %al
jne 0xd812
jmp 0xd81e
movl $0x9, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6b6c(%rip), %rsi      # 0x14395
callq 0xd980
testb $0x1, %al
jne 0xd834
jmp 0xd83d
movl $0xa, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6b50(%rip), %rsi      # 0x14398
callq 0xd980
testb $0x1, %al
jne 0xd853
jmp 0xd85c
movl $0xb, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6b39(%rip), %rsi      # 0x143a0
callq 0xd980
testb $0x1, %al
jne 0xd872
jmp 0xd87b
movl $0xc, -0x4(%rbp)
jmp 0xd8a1
movq -0x10(%rbp), %rdi
leaq 0x6b22(%rip), %rsi      # 0x143a8
callq 0xd980
testb $0x1, %al
jne 0xd891
jmp 0xd89a
movl $0xd, -0x4(%rbp)
jmp 0xd8a1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xe864
movq -0x18(%rbp), %rdi
callq 0xe8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe7e0
leaq 0xd969(%rip), %rax      # 0x1c1d4
cmpl $0x1, (%rax)
je 0xe87c
leaq 0xd95d(%rip), %rax      # 0x1c1d4
cmpl $0x3, (%rax)
jne 0xe89e
movq 0xd745(%rip), %rdi      # 0x1bfc8
leaq 0x5c05(%rip), %rsi      # 0x1448f
callq 0x31b0
movq %rax, %rdi
movq 0xd71f(%rip), %rsi      # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)