LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
leaq 0x28(%rdi), %rsi
leaq -0x90(%rbp), %rdi
callq 0x3210
leaq 0x612f(%rip), %rsi      # 0xb14b
leaq -0x70(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30a0
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x348c
leaq -0x70(%rbp), %rdi
callq 0x30c0
leaq -0x90(%rbp), %rdi
callq 0x30c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x5073
leaq 0x60e2(%rip), %rsi      # 0xb14c
callq 0x8386
testb %al, %al
je 0x50a3
movq 0xbf4e(%rip), %rdi      # 0x10fc8
leaq 0x60cc(%rip), %rsi      # 0xb14d
callq 0x3180
movq %rax, %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x3614
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x8590
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x30c0
testq %r14, %r14
je 0x50da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8586
jmp 0x508e
movq 0xbee7(%rip), %rdi      # 0x10fc8
leaq 0x6076(%rip), %rsi      # 0xb15e
callq 0x3180
movq %rax, %rdi
callq 0x30d0
jmp 0x508e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
jmp 0x5129
jmp 0x5126
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x30c0
jmp 0x5118
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x30c0
jmp 0x5132
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3614
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28(%rdi), %rsi
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x3210
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x3574
leaq 0x3821(%rip), %rsi      # 0xb14c
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x8396
movl %eax, %r15d
movq %r14, %rdi
callq 0x30c0
leaq -0x70(%rbp), %rdi
callq 0x30c0
testb %r15b, %r15b
je 0x796b
movq 0x9671(%rip), %rdi      # 0x10fc8
leaq 0x39c0(%rip), %rsi      # 0xb31e
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq 0x48(%rbx), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
leaq -0x50(%rbp), %r15
cmpq -0x30(%rbp), %rbx
je 0x79d8
movq (%rbx), %r12
movl %r14d, %esi
movq 0x9634(%rip), %rdi      # 0x10fc8
callq 0x3110
movq %rax, %rdi
pushq $0x9
popq %rsi
callq 0x31d0
movq %rax, %r13
movq (%r12), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %r13, %rdi
movq %r15, %rsi
callq 0x3150
movq %rax, %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x30c0
incl %r14d
addq $0x8, %rbx
jmp 0x7981
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x79f7
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
leaq 0x28(%rdi), %rsi
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x3210
leaq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x3574
leaq -0x48(%rbp), %rdi
callq 0x30c0
leaq 0x379c(%rip), %rsi      # 0xb331
leaq -0x28(%rbp), %rdi
callq 0x8386
xorl %ecx, %ecx
testb %al, %al
jne 0x7beb
leaq 0x3788(%rip), %rsi      # 0xb333
leaq -0x28(%rbp), %rdi
callq 0x8386
testb %al, %al
je 0x7bbc
pushq $0x1
jmp 0x7bea
leaq 0x3772(%rip), %rsi      # 0xb335
leaq -0x28(%rbp), %rdi
callq 0x8386
testb %al, %al
je 0x7bd4
pushq $0x2
jmp 0x7bea
leaq 0x375c(%rip), %rsi      # 0xb337
leaq -0x28(%rbp), %rdi
callq 0x8386
testb %al, %al
je 0x7c04
pushq $0x3
popq %rcx
leaq 0x959a(%rip), %rax      # 0x1118c
movl %ecx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x30c0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq 0x93bd(%rip), %rdi      # 0x10fc8
leaq 0x3727(%rip), %rsi      # 0xb339
callq 0x3180
movq %rax, %rdi
callq 0x30d0
jmp 0x7bf4
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
jmp 0x7c31
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/talyerushalmy[P]SimpleFileSystem/src/Commands.cpp
// Function: ExecCommand::execute(FileSystem&)
void ExecCommand::execute(FileSystem& fs)
{
	try
	{
		unsigned int input = stoi(StringTools::trim(this->getArgs()));
		if (input >= this->history.size() || (StringTools::trim(this->getArgs()) != "0" && input == 0))
		{
			std::cout << "Command not found" << std::endl;
			return;
		}
		std::string command = this->history[input]->toString();
		std::cout << command << std::endl;
	}
	catch (int e)
	{
		std::cout << "Command not found" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x3210
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3574
leaq -0x48(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x83a3
movl %eax, %r14d
leaq -0x48(%rbp), %rdi
callq 0x30c0
leaq -0x68(%rbp), %rdi
callq 0x30c0
movl %r14d, %r13d
movq 0x48(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x8005
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x3210
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3574
leaq 0x3356(%rip), %rsi      # 0xb331
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x8396
movl %eax, %r15d
movq %r12, %rdi
callq 0x30c0
leaq -0x68(%rbp), %rdi
callq 0x30c0
testl %r14d, %r14d
jne 0x8022
testb %r15b, %r15b
je 0x8022
movq 0x8fbc(%rip), %rdi      # 0x10fc8
leaq 0x334c(%rip), %rsi      # 0xb35f
callq 0x3180
movq %rax, %rdi
callq 0x30d0
jmp 0x8058
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x8(%rax)
movq 0x8f8a(%rip), %rdi      # 0x10fc8
leaq -0x48(%rbp), %rsi
callq 0x3150
movq %rax, %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x30c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x809d
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x8094
jmp 0x808a
jmp 0x809d
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30c0
jmp 0x8090
movq %rdx, %r14
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x30c0
jmp 0x80a3
jmp 0x809d
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x80db
movq %rbx, %rdi
callq 0x30b0
movq 0x8f10(%rip), %rdi      # 0x10fc8
leaq 0x32a0(%rip), %rsi      # 0xb35f
callq 0x3180
movq %rax, %rdi
callq 0x30d0
callq 0x3270
jmp 0x8058
movq %rax, %rbx
callq 0x3270
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f76(%rip), %rsi      # 0xb14c
callq 0x8386
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x82f2
leaq 0x3183(%rip), %rsi      # 0xb371
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x8201
pushq $0x2
jmp 0x82f1
leaq 0x316d(%rip), %rsi      # 0xb375
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x821b
pushq $0x3
jmp 0x82f1
leaq 0x3156(%rip), %rsi      # 0xb378
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x8235
pushq $0x4
jmp 0x82f1
leaq 0x313f(%rip), %rsi      # 0xb37b
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x824f
pushq $0x5
jmp 0x82f1
leaq 0x312b(%rip), %rsi      # 0xb381
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x8269
pushq $0x6
jmp 0x82f1
leaq 0x3118(%rip), %rsi      # 0xb388
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x8280
pushq $0x7
jmp 0x82f1
leaq 0x3104(%rip), %rsi      # 0xb38b
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x8297
pushq $0x8
jmp 0x82f1
leaq 0x30f0(%rip), %rsi      # 0xb38e
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x82ae
pushq $0x9
jmp 0x82f1
leaq 0x30e0(%rip), %rsi      # 0xb395
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x82c5
pushq $0xa
jmp 0x82f1
leaq 0x30cc(%rip), %rsi      # 0xb398
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x82dc
pushq $0xb
jmp 0x82f1
leaq 0x30bd(%rip), %rsi      # 0xb3a0
movq %rbx, %rdi
callq 0x8386
testb %al, %al
je 0x82f9
pushq $0xc
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x30a8(%rip), %rsi      # 0xb3a8
movq %rbx, %rdi
callq 0x8386
testb %al, %al
pushq $0xd
popq %rcx
pushq $0x1
popq %rax
cmovnel %ecx, %eax
jmp 0x82f2
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x88b5
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
leaq 0x88d0(%rip), %rax      # 0x1118c
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x88e1
movq 0x86fb(%rip), %rdi      # 0x10fc8
leaq 0x2bbb(%rip), %rsi      # 0xb48f
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8911
movq (%rdi), %rax
callq *0x10(%rax)
andq $0x0, 0x8(%rbx)
leaq 0x886f(%rip), %rax      # 0x1118c
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x8942
movq 0x869a(%rip), %rdi      # 0x10fc8
leaq 0x2b90(%rip), %rsi      # 0xb4c5
callq 0x3180
movq %rax, %rdi
callq 0x30d0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x363f
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x89b6
movq (%rsi), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x87cf(%rip), %rax      # 0x1118c
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x89e2
movq 0x85fa(%rip), %rdi      # 0x10fc8
leaq 0x2b30(%rip), %rsi      # 0xb505
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x8bfb
movq %rax, 0x30(%rbx)
leaq 0x8(%r12), %rsi
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x3210
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x30f0
leaq 0x28(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x30c0
movq 0x40(%r12), %rax
movq %rbx, -0x40(%rbp)
movq %rax, 0x40(%rbx)
movq 0x28(%r12), %r15
movq 0x30(%r12), %rbx
leaq 0x8121(%rip), %r14      # 0x10d68
cmpq %rbx, %r15
je 0x8ceb
movq (%r15), %r13
testq %r13, %r13
je 0x8ce2
movq %r13, %rdi
movq %r14, %rsi
leaq 0x810f(%rip), %rdx      # 0x10d78
xorl %ecx, %ecx
callq 0x31c0
testq %rax, %rax
je 0x8c98
movq %rax, %r12
pushq $0x48
popq %rdi
callq 0x3190
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x8b0c
movq -0x40(%rbp), %rax
movq %rax, 0x40(%r13)
jmp 0x8cca
movq %r13, %rdi
movq %r14, %rsi
leaq 0x80eb(%rip), %rdx      # 0x10d90
xorl %ecx, %ecx
callq 0x31c0
testq %rax, %rax
je 0x8ce2
movq %rax, %r12
pushq $0x30
popq %rdi
callq 0x3190
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x83c4
movq %r13, -0x30(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa4c8
leaq 0x8086(%rip), %r14      # 0x10d68
addq $0x8, %r15
jmp 0x8c47
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x30c0
jmp 0x8d15
jmp 0x8d0a
movq %rax, %rbx
movq %r13, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8d43
movq %rsi, %r14
movq %rbx, %rdi
callq 0x8d78
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8bd6
leaq 0x8442(%rip), %rax      # 0x1118c
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x8d6f
movq 0x826d(%rip), %rdi      # 0x10fc8
leaq 0x27fc(%rip), %rsi      # 0xb55e
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %r14, %rax
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x8dac
cmpq %rcx, %r14
je 0x8da8
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x91e8
movq 0x28(%rbx), %rax
jmp 0x8d89
movq %rax, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x8, %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x3210
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x30f0
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x40(%r14)
movq 0x28(%r14), %r12
movq 0x30(%r14), %r13
leaq 0x28(%rbx), %r14
leaq -0x30(%rbp), %r15
cmpq %r13, %r12
je 0x8f9e
movq (%r12), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9596
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x8f98
leaq 0x7de7(%rip), %rsi      # 0x10d68
leaq 0x7df0(%rip), %rdx      # 0x10d78
xorl %ecx, %ecx
callq 0x31c0
testq %rax, %rax
je 0x8f98
movq %rbx, 0x40(%rax)
addq $0x8, %r12
jmp 0x8f59
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8fe7
movq %rsi, %r14
movq %rbx, %rdi
callq 0x8d78
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8f00
leaq 0x819e(%rip), %rax      # 0x1118c
movl (%rax), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x9013
movq 0x7fc9(%rip), %rdi      # 0x10fc8
leaq 0x25ce(%rip), %rsi      # 0xb5d4
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x3210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x90c2
movl %eax, %r14d
leaq -0x38(%rbp), %rdi
callq 0x30c0
testb %r14b, %r14b
jne 0x90a4
leaq 0x28(%rbx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x9596
movq (%r14), %rdi
testq %rdi, %rdi
je 0x90a4
leaq 0x7cdb(%rip), %rsi      # 0x10d68
leaq 0x7ce4(%rip), %rdx      # 0x10d78
xorl %ecx, %ecx
callq 0x31c0
testq %rax, %rax
je 0x90a4
movq %rbx, 0x40(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %r12
leaq -0x48(%rbp), %r14
movq %rax, %r13
cmpq %r12, %rax
je 0x9119
movq (%r13), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x3210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3030
movl %eax, %r15d
movq %r14, %rdi
callq 0x30c0
leaq 0x8(%r13), %rax
testl %r15d, %r15d
jne 0x90e2
cmpq %r12, %r13
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::getSize()
int Directory::getSize()
{
	int size = 0;
	for (BaseFile* child : this->children)
		size += child->getSize();
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x92ab
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addl %eax, %ebx
addq $0x8, %r14
jmp 0x9296
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::getAbsolutePath[abi:cxx11]()
std::string Directory::getAbsolutePath()
{
	if (this->parent == NULL)
		return this->getName();
	if (parent->getName().compare("/") != 0)
		return parent->getAbsolutePath() + '/' + this->getName();
	return parent->getAbsolutePath() + this->getName();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rsi
testq %rsi, %rsi
je 0x9360
addq $0x8, %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x3210
leaq 0x1eea(%rip), %rsi      # 0xb1db
movq %r15, %rdi
callq 0x3080
movl %eax, %r12d
movq %r15, %rdi
callq 0x30c0
testl %r12d, %r12d
je 0x9371
movq 0x40(%r14), %rsi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x92b8
leaq -0x40(%rbp), %rdi
pushq $0x2f
popq %rdx
movq %r15, %rsi
callq 0x95f3
addq $0x8, %r14
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x3210
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x8315
leaq -0x80(%rbp), %rdi
callq 0x30c0
leaq -0x40(%rbp), %rdi
callq 0x30c0
leaq -0x60(%rbp), %rdi
jmp 0x93ab
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
jmp 0x93b0
movq 0x40(%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x92b8
addq $0x8, %r14
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3210
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x8315
leaq -0x60(%rbp), %rdi
callq 0x30c0
leaq -0x40(%rbp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x30c0
jmp 0x93d1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x93fa
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x30c0
jmp 0x93e8
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30c0
jmp 0x93f6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %r14
cmpq %rbx, %r13
je 0x947e
movq (%r13), %r15
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3210
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x3030
movl %eax, %r12d
movq %r14, %rdi
callq 0x30c0
addq $0x8, %r13
testl %r12d, %r12d
jne 0x9429
leaq 0x7903(%rip), %rsi      # 0x10d68
leaq 0x790c(%rip), %rdx      # 0x10d78
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x31c0
testq %rax, %rax
setne %al
jmp 0x9480
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %r14
cmpq %rbx, %r13
je 0x94fc
movq (%r13), %r15
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3210
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x3030
movl %eax, %r12d
movq %r14, %rdi
callq 0x30c0
addq $0x8, %r13
testl %r12d, %r12d
jne 0x94c5
jmp 0x94ff
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
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
cmpq %rcx, %rax
je 0x3740
addsd (%rdi,%rcx,8), %xmm2
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
jmp 0x372c
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorpd %xmm3, %xmm3
xorpd %xmm7, %xmm7
cmpq %rcx, %rax
je 0x3792
movsd (%rdi,%rcx,8), %xmm4
subsd %xmm2, %xmm4
movsd (%rsi,%rcx,8), %xmm5
subsd %xmm1, %xmm5
movapd %xmm4, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm6, %xmm0
mulsd %xmm5, %xmm4
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm3
addsd %xmm4, %xmm7
incq %rcx
jmp 0x375a
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
mulsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37ae
sqrtsd %xmm0, %xmm0
jmp 0x37c1
movsd %xmm7, -0x8(%rbp)
callq 0x3180
xorpd %xmm1, %xmm1
movsd -0x8(%rbp), %xmm7
ucomisd %xmm1, %xmm0
jne 0x37c9
jnp 0x37d7
divsd %xmm0, %xmm7
movapd %xmm7, %xmm0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x4ffa(%rip), %rdi      # 0x87d8
movsd %xmm7, -0x8(%rbp)
callq 0x3060
movsd %xmm0, -0x10(%rbp)
movq 0x97d4(%rip), %rax      # 0xcfc8
movq (%rax), %rcx
leaq 0x4d16(%rip), %rdi      # 0x8514
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x3360
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm7
jmp 0x37c9
// File: /workspace/github_cpp_makefile_star2_O2/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, %ecx
movq %rsp, %rax
leaq 0xf(,%rcx,4), %rdx
andq $-0x10, %rdx
subq %rdx, %rax
movq %rax, %rsp
xorl %edx, %edx
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
cmpq %r8, %rdx
je 0x3e54
andl $0x0, (%rax,%rdx,4)
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r10, %rcx
je 0x3e4f
movl (%rdi,%r10,4), %r11d
cmpl (%rdi,%rdx,4), %r11d
jne 0x3e4a
incl %r9d
movl %r9d, (%rax,%rdx,4)
incq %r10
jmp 0x3e34
incq %rdx
jmp 0x3e25
movl (%rax), %ecx
movslq %esi, %rsi
xorl %edx, %edx
pushq $0x1
popq %r8
cmpq %rsi, %r8
jge 0x3e78
movl (%rax,%r8,4), %r9d
cmpl %ecx, %r9d
cmovgl %r8d, %edx
cmovgl %r9d, %ecx
incq %r8
jmp 0x3e5f
movslq %edx, %rax
movl (%rdi,%rax,4), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
je 0x3eae
movsd (%rdi,%rax,8), %xmm1
subsd (%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x3e92
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3ebe
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rsi, %rax
je 0x3f0b
movsd (%rdi,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3f06
jp 0x3f06
movb $0x1, %r8b
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x3f00
movl (%rdx,%r9,4), %r10d
cmpq %r10, %rax
setne %r10b
andb %r10b, %r8b
incq %r9
jmp 0x3ee8
testb $0x1, %r8b
jne 0x3f2f
incq %rax
jmp 0x3ed0
pushq %rbp
movq %rsp, %rbp
movq 0x90b2(%rip), %rax      # 0xcfc8
movq (%rax), %rcx
leaq 0x459e(%rip), %rdi      # 0x84be
pushq $0x55
popq %rsi
pushq $0x1
popq %rdx
callq 0x3360
pushq $-0x1
popq %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]codecon/src/golf.cc
// Function: solve(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>> const&, unsigned int, unsigned int, unsigned int)
auto solve(const std::vector<std::vector<unsigned>>& map, unsigned target,
           unsigned position, unsigned steps) -> unsigned {
  if (steps > 0u) {
    return std::accumulate(
        std::begin(map[position]), std::end(map[position]), 0u,
        [&map, target, steps](unsigned acc, unsigned newPos) {
          return acc + solve(map, target, newPos, steps - 1);
        });
  }
  if (position == target) {
    return 1u;
  }
  return 0u;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %ecx, %ecx
je 0x12a7
movl %ecx, %ebp
movq %rdi, %r14
movl %edx, %eax
movq (%rdi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r12
movq 0x8(%rcx,%rax), %r13
decl %ebp
xorl %r15d, %r15d
cmpq %r13, %r12
je 0x12b0
movl (%r12), %edx
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %ecx
callq 0x125c
addl %eax, %r15d
addq $0x4, %r12
jmp 0x1289
xorl %r15d, %r15d
cmpl %ebx, %edx
sete %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/./lib/QueryAutomaton.h
// Function: QueryAutomaton::updateStateTransInfo(int, bool, int, int, char*, int)
void updateStateTransInfo(int cur_state, bool is_final_state, int exp_type_in_obj, int exp_type_in_arr, char* exp_key, int next_state) {
        int cur_idx = cur_state - 1;
        int next_idx = next_state - 1;
        int trans_idx = 0;
        if (exp_key != NULL) {
            strcpy(mDfa.trans_ele[cur_idx].t_str_info[trans_idx].key, exp_key);
            mDfa.trans_ele[cur_idx].t_str_info[trans_idx].key_len = strlen(exp_key);
        }
        if (exp_type_in_obj != NONE)
            mDfa.trans_ele[cur_idx].t_str_info[trans_idx].exp_type_in_obj = exp_type_in_obj;
        if (exp_type_in_arr != NONE)
            mDfa.trans_ele[cur_idx].t_str_info[trans_idx].exp_type_in_arr = exp_type_in_arr;
        mDfa.trans_ele[cur_idx].t_str_info[trans_idx].next_state = next_state;
        mDfa.trans_ele[cur_idx].matched_state = is_final_state; 
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdi, %r14
decl %esi
movslq %esi, %rbx
testq %r9, %r9
je 0x16705
movq %r9, %r12
imulq $0x49c, %rbx, %rax      # imm = 0x49C
leaq (%r14,%rax), %r13
addq $0x4, %r13
movq %r13, %rdi
movq %r9, %rsi
movl %edx, 0x4(%rsp)
callq 0x135d0
movq %r12, %rdi
callq 0x13370
movl 0x4(%rsp), %edx
movl %eax, 0x64(%r13)
cmpl $0x6c, %r15d
je 0x16717
imulq $0x49c, %rbx, %rax      # imm = 0x49C
movl %r15d, 0x6c(%r14,%rax)
movl 0x40(%rsp), %eax
cmpl $0x6c, %ebp
je 0x1672c
imulq $0x49c, %rbx, %rcx      # imm = 0x49C
movl %ebp, 0x70(%r14,%rcx)
imulq $0x49c, %rbx, %rcx      # imm = 0x49C
movl %eax, 0x74(%r14,%rcx)
movb %dl, 0x490(%r14,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6e0(%rdi), %r14
movq %r14, %rdi
callq 0x24c2a
leaq 0xef10(%rbx), %rax
movq %rax, 0xef00(%rbx)
andq $0x0, 0xef08(%rbx)
movb $0x0, 0xef10(%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x96d80
movq %rsp, %rdi
movq %r14, %rsi
callq 0x162fc
movq %rsp, %rdi
callq 0x945f0
andq $0x0, 0xef08(%rbx)
movq 0xef00(%rbx), %rax
movb $0x0, (%rax)
andq $0x0, 0xeef8(%rbx)
movl $0x2710, %edi           # imm = 0x2710
callq 0x25f70
movq %rax, 0x6d0(%rbx)
movq %rbx, %rdi
callq 0x1680e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x945f0
jmp 0x167f6
movq %rax, %r14
addq $0xef00, %rbx           # imm = 0xEF00
movq %rbx, %rdi
callq 0x945f0
movq %r14, %rdi
callq 0x13720
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xad879(%rip), %ymm0 # ymm0 = mem[0,1,0,1]
vmovaps %ymm0, 0x120(%rdi)
vbroadcastsd 0xad818(%rip), %ymm0 # 0xc4040
vbroadcastsd 0xad817(%rip), %ymm1 # 0xc4048
vmovaps %ymm0, 0x100(%rdi)
vmovaps %ymm1, 0x140(%rdi)
vbroadcastsd 0xad806(%rip), %ymm0 # 0xc4050
vmovaps %ymm0, 0x160(%rdi)
vbroadcastsd 0xad7fd(%rip), %ymm0 # 0xc4058
vmovaps %ymm0, 0x180(%rdi)
vbroadcastsd 0xad7f4(%rip), %ymm0 # 0xc4060
vbroadcastsd 0xad7f3(%rip), %ymm1 # 0xc4068
vmovaps %ymm0, 0x1a0(%rdi)
vmovaps %ymm1, 0x1c0(%rdi)
vbroadcastsd 0xad7e2(%rip), %ymm0 # 0xc4070
vmovaps %ymm0, 0x1e0(%rdi)
vbroadcastsd 0xad7d9(%rip), %ymm0 # 0xc4078
vmovaps %ymm0, 0x200(%rdi)
vbroadcastsd 0xad7d0(%rip), %ymm0 # 0xc4080
vmovaps %ymm0, 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)
andq $0x0, 0x88(%rdi)
vxorps %xmm1, %xmm1, %xmm1
vmovups %ymm1, 0x278(%rdi)
vmovups %ymm1, 0x281(%rdi)
andq $0x0, 0x2c0(%rdi)
vmovaps %xmm0, 0x2b0(%rdi)
orq $-0x1, 0x270(%rdi)
andq $0x0, 0x2a8(%rdi)
andq $0x0, 0xef08(%rdi)
movq 0xef00(%rdi), %rax
movb $0x0, (%rax)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::setRecordText(char*, long)
void QueryProcessor::setRecordText(char* rec_text, long length) {
    this->mRecord = rec_text;
    this->mRecordLength = length;
    this->mNumTmpWords = length / 32;
    this->mNumWords = length / 64; 
}

// Assembly:
movq %rdx, %rcx
movq %rsi, 0x2c8(%rdi)
movq %rdx, 0x2d0(%rdi)
pushq $0x20
popq %rsi
movq %rdx, %rax
cqto
idivq %rsi
movq %rax, 0x2d8(%rdi)
pushq $0x40
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
movq %rax, 0x2e0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_colon(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_colon(bitmap& bm) {
    unsigned long colonbit0, colonbit;
    colonbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_colon));
    colonbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_colon));
    bm.colonbit = (colonbit << 32) | colonbit0;
    bm.colonbit = bm.colonbit & (~str_mask);
}

// Assembly:
vmovdqa 0x160(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, (%rsi)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_comma(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_comma(bitmap& bm) {
    unsigned long commabit0, commabit;
    commabit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_comma));
    commabit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_comma));
    bm.commabit = (commabit << 32) | commabit0;
    bm.commabit = bm.commabit & (~str_mask);
}

// Assembly:
vmovdqa 0x1e0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x8(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_lbrace(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_lbrace(bitmap& bm) {
    unsigned long lbracebit0, lbracebit;
    lbracebit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_lbrace));
    lbracebit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_lbrace));
    bm.lbracebit = (lbracebit << 32) | lbracebit0;
    bm.lbracebit = bm.lbracebit & (~str_mask);
}

// Assembly:
vmovdqa 0x1a0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x10(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_rbrace(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_rbrace(bitmap& bm) {
    unsigned long rbracebit0, rbracebit;
    rbracebit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_rbrace));
    rbracebit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_rbrace));
    bm.rbracebit = (rbracebit << 32) | rbracebit0;
    bm.rbracebit = bm.rbracebit & (~str_mask);
}

// Assembly:
vmovdqa 0x1c0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x18(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_lbracket(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_lbracket(bitmap& bm) {
    unsigned long lbracketbit0, lbracketbit;
    lbracketbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_lbracket));
    lbracketbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_lbracket));
    bm.lbracketbit = (lbracketbit << 32) | lbracketbit0;
    bm.lbracketbit = bm.lbracketbit & (~str_mask);
}

// Assembly:
vmovdqa 0x200(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x20(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_rbracket(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_rbracket(bitmap& bm) {
    unsigned long rbracketbit0, rbracketbit;
    rbracketbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_rbracket));
    rbracketbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_rbracket));
    bm.rbracketbit = (rbracketbit << 32) | rbracketbit0;
    bm.rbracketbit = bm.rbracketbit & (~str_mask);
}

// Assembly:
vmovdqa 0x220(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm1, %eax
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x28(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rdi
movq (%rsi), %rax
pushq $0x40
popq %rcx
cqto
idivq %rcx
movq %rdx, %rcx
pushq $0x1
popq %rdx
shlq %cl, %rdx
movq %rdx, %rax
negq %rax
movq %rax, %rsi
btcq %rcx, %rsi
movq (%rdi), %rcx
andq %rsi, %rcx
movq %rcx, (%rdi)
je 0x16ddf
movq %rcx, %rdi
negq %rdi
andq %rcx, %rdi
movq %rdi, %rax
subq %rdx, %rax
orq %rdi, %rax
movb $0x1, %dl
jmp 0x16de6
btsq $0x3f, %rax
xorl %edx, %edx
andq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16e52
leaq -0x1(%rax), %rcx
andq %rcx, %rax
movq %rax, (%rsi)
decl %edx
jmp 0x16e3f
movq 0x270(%rdi), %rcx
shlq $0x6, %rcx
bsfq %rax, %rax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18b17
btq %rdi, %rdx
jae 0x18b17
movq %rcx, (%rsi)
incq %rcx
jmp 0x18af5
btq %rdi, %rdx
jae 0x18b24
incq %rcx
movq %rcx, (%rsi)
movzbl (%rax,%rcx), %edi
cmpq $0x20, %rdi
jbe 0x18b0e
cmpb $0x5d, %dil
je 0x18b47
cmpb $0x2c, %dil
jne 0x18b36
incq %rcx
movq %rcx, (%rsi)
movzbl (%rax,%rcx), %r8d
cmpq $0x20, %r8
ja 0x18b47
btq %r8, %rdx
jb 0x18b30
cmpb $0x5d, %dil
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::hasMoreAttributes(long&)
__attribute__((always_inline)) bool QueryProcessor::hasMoreAttributes(long& pos) {
    // if current character is blank, skip this character until meeting a non-blank character
    while (mRecord[pos] == ' ') ++pos;
    ++pos;
    while (mRecord[pos] == ' ') {
        ++pos;
    }
    if (mRecord[pos] == '}') {
        return false;
    }
    if (mRecord[pos] == ',') ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n') ++pos; 
    return true;
}

// Assembly:
movq 0x2c8(%rdi), %rax
movq (%rsi), %rcx
incq %rcx
cmpb $0x20, -0x1(%rax,%rcx)
jne 0x19be9
movq %rcx, (%rsi)
jmp 0x19bda
movq %rcx, (%rsi)
movb (%rax,%rcx), %dl
incq %rcx
cmpb $0x20, %dl
je 0x19be9
cmpb $0x7d, %dl
je 0x19c1c
cmpb $0x2c, %dl
je 0x19c06
decq %rcx
jmp 0x19c09
movq %rcx, (%rsi)
movzbl (%rax,%rcx), %edi
cmpl $0x20, %edi
je 0x19c17
cmpl $0xa, %edi
jne 0x19c1c
incq %rcx
jmp 0x19c06
cmpb $0x7d, %dl
setne %al
retq
nop