LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::fastEnqueue(std::function<void ()> 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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3130
movl %eax, %ebp
testb %al, %al
je 0x4540
movb 0x28f8(%rbx), %al
testb $0x1, %al
je 0x4540
addq $0x28c8, %rbx           # imm = 0x28C8
movq %rbx, %rdi
callq 0x30f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1740
movq %rax, %r14
testl %edx, %edx
je 0x1726
cmpl $0x3, %edx
je 0x1719
cmpl $0x2, %edx
jne 0x172e
movq 0x8(%rbx), %rax
movl (%r15), %ecx
movl %ecx, (%rax,%r14,8)
movl $0x0, 0x4(%rax,%r14,8)
jmp 0x172e
movl (%r15), %eax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
jmp 0x172e
movq %rbx, %rdi
callq 0x1862
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_O3/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 0xacc2
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc02e
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0xf54b(%rip), %rdi      # 0x12fd0
callq 0x3200
leaq 0xa88b(%rip), %rsi      # 0xe31c
movl $0x1, %edx
movq %rax, %rdi
callq 0x3200
leaq -0x38(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3ab0
callq 0x31a0
movq 0xf529(%rip), %rdi      # 0x12fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %edx
movq 0xf50e(%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 0x3b09
callq 0x31a0
leaq 0xa570(%rip), %rsi      # 0xe080
leaq -0x68(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x3bdb
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movq -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x3c48
movq %r14, %rdi
callq 0xacc2
movq %r13, %rdi
movq %rax, %rsi
callq 0xc02e
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0xf479(%rip), %rdi      # 0x12fd0
callq 0x3200
movl $0x1, %edx
movq %rax, %rdi
leaq 0xa7b1(%rip), %rsi      # 0xe31c
callq 0x3200
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3b7e
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 0x3bc4
callq 0x31a0
movq %r12, %rdi
leaq 0xa4b2(%rip), %rsi      # 0xe080
callq 0x3080
testl %eax, %eax
jne 0x3b29
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3bed
callq 0x31a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c2b
jmp 0x3c2b
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x3c24
jmp 0x3c2e
jmp 0x3c2b
jmp 0x3c2b
jmp 0x3c2b
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3c2e
callq 0x31a0
jmp 0x3c2e
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3c40
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f53
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4fae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x532a
addq $0x18, %r14
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xb0d0
leaq 0xe24a(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x4fa6
movq 0xe065(%rip), %r14      # 0x12fd0
leaq 0x9141(%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_O3/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 0x520f
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4fae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5174
leaq 0xdf8e(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x5262
movq 0xdda9(%rip), %r14      # 0x12fd0
leaq 0x8f03(%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_O3/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 0x392c
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x86e7(%rip), %rsi      # 0xe173
leaq 0x86e1(%rip), %rdx      # 0xe174
leaq -0x70(%rbp), %rdi
callq 0xab8a
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x34ec
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5abe
callq 0x31a0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5acf
callq 0x31a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x5b3e
leaq 0x868d(%rip), %rsi      # 0xe174
callq 0x3080
testl %eax, %eax
je 0x5b3e
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 0x392c
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xacd6
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x5b2c
callq 0x31a0
testq %r14, %r14
je 0x5b98
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaccc
jmp 0x5b84
movq 0xd48b(%rip), %rbx      # 0x12fd0
leaq 0x8629(%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 0xd459(%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 0xd431(%rip), %rbx      # 0x12fd0
leaq 0x85e0(%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 0xd3ff(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x5b84
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c21
callq 0x31a0
jmp 0x5c21
jmp 0x5c1e
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c0b
callq 0x31a0
jmp 0x5c0b
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c2a
callq 0x31a0
jmp 0x5c2a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x36b8
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x392c
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x35f2
leaq 0x46a9(%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 0x9aeb
callq 0x31a0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x9af9
callq 0x31a0
testl %r14d, %r14d
je 0x9b40
movq 0x94cb(%rip), %r14      # 0x12fd0
leaq 0x483a(%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 0x9bf2
xorl %r14d, %r14d
movq (%r13), %r15
movl %r14d, %esi
movq 0x9467(%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 0x9be1
callq 0x31a0
incl %r14d
addq $0x8, %r13
cmpq -0x50(%rbp), %r13
jne 0x9b5b
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 0x9c1f
jmp 0x9c24
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9c24
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x392c
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x35f2
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x9eec
callq 0x31a0
leaq 0x4466(%rip), %rsi      # 0xe359
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9f88
leaq 0x4450(%rip), %rsi      # 0xe35b
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9f8c
leaq 0x443e(%rip), %rsi      # 0xe35d
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9f93
leaq 0x442c(%rip), %rsi      # 0xe35f
leaq -0x30(%rbp), %rdi
callq 0x3080
testl %eax, %eax
je 0x9f9a
movq 0x9089(%rip), %rbx      # 0x12fd0
leaq 0x4413(%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 0x9057(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x9fa8
xorl %eax, %eax
jmp 0x9f9f
movl $0x1, %eax
jmp 0x9f9f
movl $0x2, %eax
jmp 0x9f9f
movl $0x3, %eax
leaq 0x91fe(%rip), %rcx      # 0x131a4
movl %eax, (%rcx)
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fba
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 0x9fe1
jmp 0x9fe6
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x9fe6
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3762(%rip), %rsi      # 0xe174
callq 0x3080
testl %eax, %eax
je 0xab34
leaq 0x3973(%rip), %rsi      # 0xe399
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab38
leaq 0x3960(%rip), %rsi      # 0xe39d
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab3f
leaq 0x394c(%rip), %rsi      # 0xe3a0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab46
leaq 0x3938(%rip), %rsi      # 0xe3a3
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab4d
leaq 0x3927(%rip), %rsi      # 0xe3a9
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab54
leaq 0x3917(%rip), %rsi      # 0xe3b0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab5b
leaq 0x3903(%rip), %rsi      # 0xe3b3
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab62
leaq 0x38ef(%rip), %rsi      # 0xe3b6
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab69
leaq 0x38df(%rip), %rsi      # 0xe3bd
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab70
leaq 0x38cb(%rip), %rsi      # 0xe3c0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab77
leaq 0x38c0(%rip), %rsi      # 0xe3c8
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
je 0xab7e
leaq 0x38b5(%rip), %rsi      # 0xe3d0
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
movl $0xd, %ecx
movl $0x1, %eax
cmovel %ecx, %eax
jmp 0xab83
xorl %eax, %eax
jmp 0xab83
movl $0x2, %eax
jmp 0xab83
movl $0x3, %eax
jmp 0xab83
movl $0x4, %eax
jmp 0xab83
movl $0x5, %eax
jmp 0xab83
movl $0x6, %eax
jmp 0xab83
movl $0x7, %eax
jmp 0xab83
movl $0x8, %eax
jmp 0xab83
movl $0x9, %eax
jmp 0xab83
movl $0xa, %eax
jmp 0xab83
movl $0xb, %eax
jmp 0xab83
movl $0xc, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb0f4
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
leaq 0x80a9(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb147
movq 0x7ec4(%rip), %r14      # 0x12fd0
leaq 0x33a4(%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_O3/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 0xb175
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rbx)
leaq 0x8020(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb1d4
movq 0x7e3b(%rip), %rbx      # 0x12fd0
leaq 0x3351(%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 0x7e09(%rip), %rdi      # 0x12fd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x3710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb277
movq (%rsi), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x7f26(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb2ca
movq 0x7d41(%rip), %r14      # 0x12fd0
leaq 0x3297(%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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb601
movq %rax, 0x30(%rbx)
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x392c
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3100
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xb63b
callq 0x31a0
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movq 0x28(%r14), %r12
movq 0x30(%r14), %rax
movq %rax, -0x40(%rbp)
cmpq %rax, %r12
je 0xb782
leaq 0x28(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x7709(%rip), %r15      # 0x12d70
movq (%r12), %r14
testq %r14, %r14
je 0xb774
movq %r14, %rdi
movq %r15, %rsi
leaq 0x76ff(%rip), %rdx      # 0x12d80
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
je 0xb6d2
movq %rax, %r13
movl $0x48, %edi
callq 0x31c0
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0xb49c
movq %rbx, 0x40(%r14)
movq %r14, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
leaq 0x76b1(%rip), %r15      # 0x12d70
je 0xb751
movq %r14, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xb774
movq %r14, %rdi
movq %r15, %rsi
leaq 0x76b9(%rip), %rdx      # 0x12d98
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
je 0xb774
movq %rax, %r14
movl $0x30, %edi
callq 0x31c0
movq %rax, %r13
leaq 0x7602(%rip), %rax      # 0x12d08
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
movq %rax, 0x8(%r13)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x392c
leaq 0x7603(%rip), %rax      # 0x12d30
movq %rax, (%r13)
movl 0x28(%r14), %eax
movl %eax, 0x28(%r13)
movq %r13, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xb760
movq %r13, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xb76d
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xd1ce
jmp 0xb774
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xd1ce
leaq 0x75fc(%rip), %r15      # 0x12d70
addq $0x8, %r12
cmpq -0x40(%rbp), %r12
jne 0xb667
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
jne 0xb7ad
jmp 0xb7b2
movq %rax, %rbx
movq %r13, %rdi
jmp 0xb7ad
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb7df
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb83a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5dc
leaq 0x79be(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xb832
movq 0x77d9(%rip), %r14      # 0x12fd0
leaq 0x2d88(%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_O3/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 0xb86f
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xbeb0
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0xb86f
cmpq %rcx, %r14
jne 0xb84e
movq %rax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x392c
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3100
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xbad5
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 0xbb50
leaq 0x28(%rbx), %r14
leaq 0x7283(%rip), %r13      # 0x12d80
movq (%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xbb18
movq %rax, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xbb24
movq %r14, %rdi
leaq -0x30(%rbp), %rdx
callq 0xc5b2
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xbb47
leaq 0x723c(%rip), %rsi      # 0x12d70
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
je 0xbb47
movq %rbx, 0x40(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0xbafd
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 0xbb70
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbb9d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb83a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xba84
leaq 0x7600(%rip), %rax      # 0x131a4
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0xbbf0
movq 0x741b(%rip), %r14      # 0x12fd0
leaq 0x2a40(%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
// File: /workspace/github_cpp_makefile_star2_O3/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::addFile(BaseFile*)
void Directory::addFile(BaseFile* file)
{
	if (!childExists(file->getName()))
	{
		this->children.push_back(file);
		if (Directory* dir = dynamic_cast<Directory*>(file))
			dir->parent = this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x392c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbcda
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xbc61
callq 0x31a0
testb %r15b, %r15b
jne 0xbcb3
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xbc7a
movq %r14, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xbc92
leaq 0x28(%rbx), %rdi
leaq -0x28(%rbp), %r14
movq %r14, %rdx
callq 0xc5b2
movq (%r14), %r14
testq %r14, %r14
je 0xbcb3
leaq 0x70d7(%rip), %rsi      # 0x12d70
leaq 0x70e0(%rip), %rdx      # 0x12d80
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
je 0xbcb3
movq %rbx, 0x40(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xbcd1
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::childExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Directory::childExists(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq 0x28(%rdi), %rbx
movq 0x30(%rdi), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, %rbx
je 0xbd5e
leaq -0x48(%rbp), %r13
addq $0x8, %rbx
leaq -0x58(%rbp), %r14
movq -0x8(%rbx), %rax
movq %r13, -0x58(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x392c
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x3040
movl %eax, %r12d
testl %eax, %eax
sete %r15b
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0xbd4a
callq 0x31a0
testl %r12d, %r12d
je 0xbd61
leaq 0x8(%rbx), %rax
cmpq -0x30(%rbp), %rbx
movq %rax, %rbx
jne 0xbd0c
jmp 0xbd61
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0xbd84
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::childDirectoryExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Directory::childDirectoryExists(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
		{
			if (dynamic_cast<Directory*>(child))
				return true;
			return false;
		}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rbx
cmpq %rbx, %r13
je 0xc3d2
leaq -0x40(%rbp), %r14
movq (%r13), %r15
movq %r14, -0x50(%rbp)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x392c
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x3040
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xc3c4
callq 0x31a0
testl %r12d, %r12d
je 0xc3d6
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xc388
xorl %eax, %eax
jmp 0xc3f4
leaq 0x6993(%rip), %rsi      # 0x12d70
leaq 0x699c(%rip), %rdx      # 0x12d80
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xc414
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::getChildByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BaseFile* Directory::getChildByName(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
			return child;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rbx
cmpq %rbx, %r13
je 0xc48c
leaq -0x40(%rbp), %r14
movq (%r13), %r15
movq %r14, -0x50(%rbp)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x392c
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x3040
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xc47e
callq 0x31a0
testl %r12d, %r12d
je 0xc48f
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xc442
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xc4b2
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/jmmccracken[P]PAI/ccmsrc.cpp
// Function: Pcorr(double*, double*, int)
double Pcorr(double dX[],double dY[],int iXY_length){

    double dEX = 0,  //expectation value of X
           dEY = 0,  //expectation value of Y
           dEXdelta,  //distance from mean for point in X
           dEYdelta,  //distance from mean for point in Y
           dSX = 0,  //variance of X
           dSY = 0,  //variance of Y
           dSXY = 0,  //covariance of X and Y
           dCovNorm;  //normalization factor for the covariance

    for(int iter = 0;iter < iXY_length;iter++ ){
        dEX += dX[iter];
        dEY += dY[iter];
    }

    dEX /= iXY_length;
    dEY /= iXY_length;

    for(int iter = 0;iter < iXY_length;iter++ ){
        dEXdelta = dX[iter]-dEX;
        dEYdelta = dY[iter]-dEY;
        dSX += dEXdelta*dEXdelta;
        dSY += dEYdelta*dEYdelta;
        dSXY += dEXdelta*dEYdelta;
    }

    dCovNorm = sqrt(dSX*dSY);
    if( dCovNorm == 0 ){
        dCovNorm = nan("");
        fprintf(stderr, "Warning in Pcorr(): division by zero\n");
    }

    return(dSXY/dCovNorm);
}

// Assembly:
xorpd %xmm1, %xmm1
xorpd %xmm8, %xmm8
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x418b
movl %edx, %eax
xorpd %xmm2, %xmm2
xorl %ecx, %ecx
xorpd %xmm3, %xmm3
addsd (%rdi,%rcx,8), %xmm2
addsd (%rsi,%rcx,8), %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x4111
testl %edx, %edx
jle 0x4182
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm2
divsd %xmm0, %xmm3
xorpd %xmm8, %xmm8
xorl %ecx, %ecx
xorpd %xmm4, %xmm4
xorpd %xmm0, %xmm0
movsd (%rdi,%rcx,8), %xmm5
subsd %xmm2, %xmm5
movsd (%rsi,%rcx,8), %xmm6
subsd %xmm3, %xmm6
movapd %xmm5, %xmm7
mulsd %xmm5, %xmm7
addsd %xmm7, %xmm0
mulsd %xmm6, %xmm5
mulsd %xmm6, %xmm6
addsd %xmm6, %xmm4
addsd %xmm5, %xmm8
incq %rcx
cmpq %rcx, %rax
jne 0x4145
mulsd %xmm4, %xmm0
jmp 0x418b
xorpd %xmm8, %xmm8
xorpd %xmm0, %xmm0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
ucomisd %xmm1, %xmm0
jb 0x41a0
sqrtsd %xmm0, %xmm0
jmp 0x41b1
movsd %xmm8, -0x10(%rbp)
callq 0x3140
movsd -0x10(%rbp), %xmm8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x41bd
jnp 0x41ce
divsd %xmm0, %xmm8
movapd %xmm8, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
movsd %xmm8, -0x10(%rbp)
callq 0x3841
movsd -0x10(%rbp), %xmm8
movsd (%rbx), %xmm0
jmp 0x41bd
// File: /workspace/github_cpp_makefile_star2_O3/jmmccracken[P]PAI/ccmsrc.cpp
// Function: iMode(int*, int)
int iMode(int iA[],int iAlength){

    int iRepetitions[iAlength];

    for(int iter = 0; iter < iAlength;iter++ ){
        iRepetitions[iter] = 0;
        for(int iter2 = 0;iter2 < iAlength;iter2++ ){
            if( iA[iter2] == iA[iter] ){
                iRepetitions[iter]++;
            }
        }
    }

    int iMaxIter = 0,
        iCurrentRepCount = iRepetitions[0];
    for (int iter = 1;iter < iAlength;iter++ ){
        if( iRepetitions[iter] > iCurrentRepCount ){
            iMaxIter = iter;
            iCurrentRepCount = iRepetitions[iter];
        }
    }

    return( iA[iMaxIter] );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movq %rsp, %rcx
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
subq %rdx, %rcx
movq %rcx, %rsp
xorl %edx, %edx
testl %esi, %esi
jle 0x44cc
movl $0x0, (%rcx,%rdx,4)
movl (%rdi,%rdx,4), %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl %r8d, (%rdi,%r10,4)
jne 0x4493
incl %r9d
movl %r9d, (%rcx,%rdx,4)
incq %r10
cmpq %r10, %rax
jne 0x4486
incq %rdx
cmpq %rax, %rdx
jne 0x4475
xorl %edx, %edx
cmpl $0x1, %esi
je 0x44cc
movl (%rcx), %esi
movl $0x1, %r8d
movl (%rcx,%r8,4), %r9d
cmpl %esi, %r9d
cmovgl %r8d, %edx
cmovgl %r9d, %esi
incq %r8
cmpq %r8, %rax
jne 0x44b2
movslq %edx, %rdx
movl (%rdi,%rdx,4), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jmmccracken[P]PAI/ccmsrc.cpp
// Function: eDist(double*, double*, int)
double eDist(double dX[],double dY[],int iXY_length){

    double dRunningSum = 0;

    for(int iter = 0; iter < iXY_length; iter++ ){
        dRunningSum += (dX[iter]-dY[iter])*(dX[iter]-dY[iter]);
    }

    return(sqrt(dRunningSum));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x4502
movl %edx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
subsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x44e8
ucomisd %xmm1, %xmm0
jb 0x450e
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/jmmccracken[P]PAI/ccmsrc.cpp
// Function: FindAndCheckIndex(double*, int, double, int*, int)
int FindAndCheckIndex(double dValues2BCompared[],int iValues2BCompared_length,double dValue2Compare,int iIndices2Check[],int iIndices2Check_length){

    bool bUniqueIndex = true,
         bFoundMatch = false;

    for(int iter = 0;iter < iValues2BCompared_length;iter++ ){
        if( dValues2BCompared[iter] == dValue2Compare ){
            bFoundMatch = true;
        }
        if( bFoundMatch ){
            bUniqueIndex = true;
            for(int iIndexCheckStep = 0;iIndexCheckStep < iIndices2Check_length;iIndexCheckStep++ ){
                bUniqueIndex &= (iter != iIndices2Check[iIndexCheckStep]);
            }
            if( bUniqueIndex ){
                return(iter);
            }
        }
        bFoundMatch = false;
    }

    fprintf(stderr, "Error in FindAndCheckIndex(): no match was found, so an index of -1 will be returned\n");
    return(-1);
}

// Assembly:
testl %esi, %esi
jle 0x4559
movl %esi, %esi
movl %ecx, %r8d
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4551
jp 0x4551
testl %ecx, %ecx
jle 0x4568
movb $0x1, %r9b
xorl %r10d, %r10d
movl (%rdx,%r10,4), %r11d
cmpq %r11, %rax
setne %r11b
andb %r11b, %r9b
incq %r10
cmpq %r10, %r8
jne 0x4536
testb %r9b, %r9b
jne 0x4568
incq %rax
cmpq %rsi, %rax
jne 0x451f
pushq %rbp
movq %rsp, %rbp
callq 0x38f4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::QueryProcessor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
QueryProcessor::QueryProcessor(string query) {
    JSONPathParser::updateQueryAutomaton(query, this->qa);
    this->mOutput.clear();
    this->mNumMatches = 0;
    this->mText = new char[MAX_TEXT_LENGTH];
    init(); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x750(%rdi), %rax
xorl %ecx, %ecx
movabsq $0x6c0000006c, %rdx     # imm = 0x6C0000006C
movl $0x49c, %edi            # imm = 0x49C
xorl %r8d, %r8d
movq %rdx, -0x4(%rax,%r8)
addq $0x74, %r8
cmpq $0x488, %r8             # imm = 0x488
jne 0x16601
movl $0x1, 0xb6c(%rbx,%rcx)
movb $0x0, 0xb7c(%rbx,%rcx)
addq %rdi, %rcx
addq %rdi, %rax
cmpq $0xe678, %rcx           # imm = 0xE678
jne 0x165fe
movl $0x0, 0xeef0(%rbx)
movl $0x1, 0x6e0(%rbx)
movl $0xffffffff, 0xed5c(%rbx) # imm = 0xFFFFFFFF
leaq 0xef10(%rbx), %r15
movq %r15, 0xef00(%rbx)
movq $0x0, 0xef08(%rbx)
movb $0x0, 0xef10(%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x259ba
leaq 0x6e0(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1617c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x166b4
callq 0x26180
xorl %eax, %eax
movq %rax, 0xef08(%rbx)
movq 0xef00(%rbx), %rcx
movb $0x0, (%rcx)
movq %rax, 0xeef8(%rbx)
movl $0x2710, %edi           # imm = 0x2710
callq 0x26ec0
movq %rax, 0x6d0(%rbx)
vbroadcastf128 0xae9a8(%rip), %ymm0 # ymm0 = mem[0,1,0,1]
vbroadcastsd 0xae94f(%rip), %ymm1 # 0xc5040
vmovaps %ymm0, 0x120(%rbx)
vmovaps %ymm1, 0x100(%rbx)
vbroadcastsd 0xae93e(%rip), %ymm0 # 0xc5048
vmovaps %ymm0, 0x140(%rbx)
vbroadcastsd 0xae935(%rip), %ymm0 # 0xc5050
vmovaps %ymm0, 0x160(%rbx)
vbroadcastsd 0xae92c(%rip), %ymm0 # 0xc5058
vbroadcastsd 0xae92b(%rip), %ymm1 # 0xc5060
vmovaps %ymm0, 0x180(%rbx)
vmovaps %ymm1, 0x1a0(%rbx)
vbroadcastsd 0xae91a(%rip), %ymm0 # 0xc5068
vmovaps %ymm0, 0x1c0(%rbx)
vbroadcastsd 0xae911(%rip), %ymm0 # 0xc5070
vmovaps %ymm0, 0x1e0(%rbx)
vbroadcastsd 0xae908(%rip), %ymm0 # 0xc5078
vbroadcastsd 0xae907(%rip), %ymm1 # 0xc5080
vmovaps %ymm0, 0x200(%rbx)
vmovaps %ymm1, 0x220(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x240(%rbx)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
movq %rax, 0x250(%rbx)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x258(%rbx)
xorl %eax, %eax
movq %rax, 0x88(%rbx)
vxorps %xmm1, %xmm1, %xmm1
vmovups %ymm1, 0x278(%rbx)
vmovups %ymm1, 0x281(%rbx)
vmovaps %xmm0, 0x2b0(%rbx)
movq %rax, 0x2c0(%rbx)
movq $-0x1, 0x270(%rbx)
movq %rax, 0x2a8(%rbx)
movq %rax, 0xef08(%rbx)
movq 0xef00(%rbx), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1682c
callq 0x26180
jmp 0x1682c
movq %rax, %r14
movq 0xef00(%rbx), %rdi
cmpq %r15, %rdi
je 0x1683d
callq 0x26180
movq %r14, %rdi
callq 0x13720
nop
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::init()
void QueryProcessor::init() {
    structural_table =
        _mm256_setr_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '{', 0, '}', 0, 0,
                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '{', 0, '}', 0, 0);
    struct_mask = _mm256_set1_epi8(0x20);
    // vectors for structural characters
    v_quote = _mm256_set1_epi8(0x22);
    v_colon = _mm256_set1_epi8(0x3a);
    v_escape = _mm256_set1_epi8(0x5c);
    v_lbrace = _mm256_set1_epi8(0x7b);
    v_rbrace = _mm256_set1_epi8(0x7d);
    v_comma = _mm256_set1_epi8(0x2c);
    v_lbracket = _mm256_set1_epi8(0x5b);
    v_rbracket = _mm256_set1_epi8(0x5d);
    // some global variables among internal functions
    top_word = -1;
    prev_iter_ends_odd_backslash = 0ULL;
    prev_iter_inside_quote = 0ULL;
    even_bits = 0x5555555555555555ULL;
    odd_bits = ~even_bits;
    start_id = 0;
    cb_mask = 0, colon_mask = 0, comma_mask = 0; mask = 0;
    colonbit = 0; quotebit = 0; commabit = 0; bracketbit = 0;
    cur_word = false;
    top_word = -1;
    cur_pos = 0; 
    this->mOutput.clear();
}

// Assembly:
vbroadcastf128 0xae841(%rip), %ymm0 # ymm0 = mem[0,1,0,1]
vbroadcastsd 0xae7e8(%rip), %ymm1 # 0xc5040
vmovaps %ymm0, 0x120(%rdi)
vmovaps %ymm1, 0x100(%rdi)
vbroadcastsd 0xae7d7(%rip), %ymm0 # 0xc5048
vmovaps %ymm0, 0x140(%rdi)
vbroadcastsd 0xae7ce(%rip), %ymm0 # 0xc5050
vmovaps %ymm0, 0x160(%rdi)
vbroadcastsd 0xae7c5(%rip), %ymm0 # 0xc5058
vbroadcastsd 0xae7c4(%rip), %ymm1 # 0xc5060
vmovaps %ymm0, 0x180(%rdi)
vmovaps %ymm1, 0x1a0(%rdi)
vbroadcastsd 0xae7b3(%rip), %ymm0 # 0xc5068
vmovaps %ymm0, 0x1c0(%rdi)
vbroadcastsd 0xae7aa(%rip), %ymm0 # 0xc5070
vmovaps %ymm0, 0x1e0(%rdi)
vbroadcastsd 0xae7a1(%rip), %ymm0 # 0xc5078
vbroadcastsd 0xae7a0(%rip), %ymm1 # 0xc5080
vmovaps %ymm0, 0x200(%rdi)
vmovaps %ymm1, 0x220(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x240(%rdi)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
movq %rax, 0x250(%rdi)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x258(%rdi)
xorl %eax, %eax
movq %rax, 0x88(%rdi)
vxorps %xmm1, %xmm1, %xmm1
vmovups %ymm1, 0x278(%rdi)
vmovups %ymm1, 0x281(%rdi)
vmovaps %xmm0, 0x2b0(%rdi)
movq %rax, 0x2c0(%rdi)
movq $-0x1, 0x270(%rdi)
movq %rax, 0x2a8(%rdi)
movq %rax, 0xef08(%rdi)
movq 0xef00(%rdi), %rax
movb $0x0, (%rax)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::get_interval(long&, unsigned long&)
__attribute__((always_inline)) IntervalInfo QueryProcessor::get_interval(long& pos, unsigned long& bitmap) {
    IntervalInfo itv_info;
    int relative_pos = pos % 64;
    unsigned long w_start = (1UL << relative_pos);
    unsigned long mask_start = w_start ^ (w_start - 1);
    bitmap = bitmap & (~mask_start);
    if (bitmap) {
        unsigned long w_end = bitmap & (-bitmap);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval & (~mask_start);
        itv_info.is_complete = true;
    } else {
        // include the last character inside the word (incomplete interval)
        unsigned long w_end = (1UL << 63);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval & (~mask_start);
        itv_info.is_complete = false;
    }
    return itv_info;
}

// Assembly:
movq (%rsi), %rcx
leal 0x3f(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
andl $0xc0, %eax
subl %eax, %ecx
movl $0x1, %edi
shlq %cl, %rdi
movq %rdi, %rax
negq %rax
movq %rax, %rsi
btcq %rcx, %rsi
movq (%rdx), %rcx
andq %rsi, %rcx
movq %rcx, (%rdx)
je 0x16e2f
movq %rcx, %rdx
negq %rdx
andq %rcx, %rdx
movq %rdx, %rax
subq %rdi, %rax
orq %rdx, %rax
movb $0x1, %dl
jmp 0x16e36
btsq $0x3f, %rax
xorl %edx, %edx
andq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::get_position(unsigned long&, int)
__attribute__((always_inline)) long QueryProcessor::get_position(unsigned long& bitmap, int number) {
    while (number > 1) {
        bitmap = bitmap & (bitmap - 1);
        --number;
    }
    unsigned long pos = top_word * 64 + __builtin_ctzll(bitmap);
    return pos;
}

// Assembly:
movq (%rsi), %rax
cmpl $0x2, %edx
jl 0x16ea9
incl %edx
movq %rax, %rcx
decq %rax
andq %rcx, %rax
decl %edx
cmpl $0x2, %edx
ja 0x16e96
movq %rax, (%rsi)
movq 0x270(%rdi), %rcx
shlq $0x6, %rcx
bsfq %rax, %rax
orq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::hasMoreElements(long&)
__attribute__((always_inline)) bool QueryProcessor::hasMoreElements(long& pos) {
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos;
    ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos; 
    if (mRecord[pos] == ']') {
        return false;
    }
    if (mRecord[pos] == ',') ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos;
    return true;
}

// Assembly:
movq 0x2c8(%rdi), %rax
movq (%rsi), %rcx
incq %rcx
movabsq $0x100002400, %rdx      # imm = 0x100002400
movzbl -0x1(%rax,%rcx), %edi
cmpq $0x20, %rdi
ja 0x18bf9
btq %rdi, %rdx
jae 0x18bf9
movq %rcx, (%rsi)
incq %rcx
jmp 0x18bd7
btq %rdi, %rdx
jae 0x18c06
incq %rcx
movq %rcx, (%rsi)
movzbl (%rax,%rcx), %edi
cmpq $0x20, %rdi
jbe 0x18bf0
cmpb $0x5d, %dil
je 0x18c29
cmpb $0x2c, %dil
jne 0x18c18
incq %rcx
movq %rcx, (%rsi)
movzbl (%rax,%rcx), %r8d
cmpq $0x20, %r8
ja 0x18c29
btq %r8, %rdx
jb 0x18c12
cmpb $0x5d, %dil
setne %al
retq
nop