LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xe8fb
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq 0xd8c6(%rip), %rax      # 0x1c1d4
cmpl $0x1, (%rax)
je 0xe91f
leaq 0xd8ba(%rip), %rax      # 0x1c1d4
cmpl $0x3, (%rax)
jne 0xe94c
movq 0xd6a2(%rip), %rdi      # 0x1bfc8
leaq 0x5b98(%rip), %rsi      # 0x144c5
callq 0x31b0
movq %rax, -0x20(%rbp)
jmp 0xe938
movq -0x20(%rbp), %rdi
movq 0xd675(%rip), %rsi      # 0x1bfb8
callq 0x31e0
jmp 0xe94a
jmp 0xe94c
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3930
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xea64
movq -0x18(%rbp), %rdi
callq 0xe8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe9e0
leaq 0xd769(%rip), %rax      # 0x1c1d4
cmpl $0x1, (%rax)
je 0xea7c
leaq 0xd75d(%rip), %rax      # 0x1c1d4
cmpl $0x3, (%rax)
jne 0xea9e
movq 0xd545(%rip), %rdi      # 0x1bfc8
leaq 0x5a7b(%rip), %rsi      # 0x14505
callq 0x31b0
movq %rax, %rdi
movq 0xd51f(%rip), %rsi      # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xf0c4
movq -0x18(%rbp), %rdi
callq 0xf110
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xedf0
leaq 0xd109(%rip), %rax      # 0x1c1d4
cmpl $0x1, (%rax)
je 0xf0dc
leaq 0xd0fd(%rip), %rax      # 0x1c1d4
cmpl $0x3, (%rax)
jne 0xf0fe
movq 0xcee5(%rip), %rdi      # 0x1bfc8
leaq 0x5474(%rip), %rsi      # 0x1455e
callq 0x31b0
movq %rax, %rdi
movq 0xcebf(%rip), %rsi      # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0xda40
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x10250
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xf16b
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0xda70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xdaa0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf174
jmp 0xf18b
leaq -0x10(%rbp), %rdi
callq 0xdae0
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0xf890
jmp 0xf131
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x10290
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xeb30
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xeb60
jmp 0xf3cb
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x78(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xda40
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xda70
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xdaa0
testb $0x1, %al
jne 0xf42c
jmp 0xf4d0
leaq -0x50(%rbp), %rdi
callq 0xdae0
movq -0x78(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
callq 0xffe0
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xf496
movq -0x80(%rbp), %rdi
leaq 0xc8fa(%rip), %rsi      # 0x1bd60
leaq 0xc903(%rip), %rdx      # 0x1bd70
xorl %eax, %eax
movl %eax, %ecx
callq 0x3210
movq %rax, -0x88(%rbp)
jmp 0xf4a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
jmp 0xf4d9
xorl %eax, %eax
movq %rax, -0x88(%rbp)
jmp 0xf4a1
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0xf4c0
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xf590
jmp 0xf4c2
leaq -0x50(%rbp), %rdi
callq 0xdb00
jmp 0xf416
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xf524
movq -0x18(%rbp), %rdi
callq 0xf110
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf390
leaq 0xcca9(%rip), %rax      # 0x1c1d4
cmpl $0x1, (%rax)
je 0xf53c
leaq 0xcc9d(%rip), %rax      # 0x1c1d4
cmpl $0x3, (%rax)
jne 0xf55e
movq 0xca85(%rip), %rdi      # 0x1bfc8
leaq 0x508a(%rip), %rsi      # 0x145d4
callq 0x31b0
movq %rax, %rdi
movq 0xca5f(%rip), %rsi      # 0x1bfb8
callq 0x31e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xeb30
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xf6a0
movb %al, -0x49(%rbp)
jmp 0xf5ee
movb -0x49(%rbp), %al
xorb $-0x1, %al
movb %al, -0x61(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0xf608
jmp 0xf684
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
leaq -0x10(%rbp), %rsi
callq 0xffe0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0xf65f
movq -0x70(%rbp), %rdi
leaq 0xc72e(%rip), %rsi      # 0x1bd60
leaq 0xc737(%rip), %rdx      # 0x1bd70
xorl %eax, %eax
movl %eax, %ecx
callq 0x3210
movq %rax, -0x78(%rbp)
jmp 0xf667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
jmp 0xf68d
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0xf667
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xf682
movq -0x60(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xf684
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdaa0
testb $0x1, %al
jne 0xf6f0
jmp 0xf761
leaq -0x28(%rbp), %rdi
callq 0xdae0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xeb30
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3040
movl %eax, -0x74(%rbp)
jmp 0xf723
leaq -0x58(%rbp), %rdi
callq 0x3130
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
jne 0xf751
movb $0x1, -0x1(%rbp)
jmp 0xf765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3130
jmp 0xf773
jmp 0xf753
leaq -0x28(%rbp), %rdi
callq 0xdb00
jmp 0xf6dd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3300
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xda40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xda70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdaa0
testb $0x1, %al
jne 0xfa5c
jmp 0xfa86
leaq -0x20(%rbp), %rdi
callq 0xdae0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xdb00
jmp 0xfa49
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
cmpq $0x0, 0x40(%rax)
jne 0xfade
movq -0xe8(%rbp), %rsi
movq -0xf8(%rbp), %rdi
callq 0xeb30
jmp 0xfc84
movq -0xe8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0xeb30
leaq -0x30(%rbp), %rdi
leaq 0x46de(%rip), %rsi      # 0x141db
callq 0x30a0
movl %eax, -0xfc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
movl -0xfc(%rbp), %eax
cmpl $0x0, %eax
je 0xfbee
movq -0xe8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xfa90
movq -0x108(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x2f, %edx
callq 0x10200
jmp 0xfb52
movq -0xe8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xeb30
jmp 0xfb67
movq -0xf8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0xd8b0
jmp 0xfb80
leaq -0xa0(%rbp), %rdi
callq 0x3130
leaq -0x50(%rbp), %rdi
callq 0x3130
leaq -0x70(%rbp), %rdi
callq 0x3130
jmp 0xfc84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xfbe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xfbd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3130
leaq -0x50(%rbp), %rdi
callq 0x3130
leaq -0x70(%rbp), %rdi
callq 0x3130
jmp 0xfc94
movq -0xe8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xfa90
movq -0xe8(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0xeb30
jmp 0xfc1a
movq -0xf8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0xd8b0
jmp 0xfc36
leaq -0xe0(%rbp), %rdi
callq 0x3130
leaq -0xc0(%rbp), %rdi
callq 0x3130
jmp 0xfc84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xfc76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3130
leaq -0xc0(%rbp), %rdi
callq 0x3130
jmp 0xfc94
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3300
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdaa0
testb $0x1, %al
jne 0xfcf3
jmp 0xfdba
leaq -0x28(%rbp), %rdi
callq 0xdae0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xeb30
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3040
movl %eax, -0x74(%rbp)
jmp 0xfd26
leaq -0x58(%rbp), %rdi
callq 0x3130
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
jne 0xfdaa
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0xfd86
movq -0x88(%rbp), %rdi
leaq 0xc00a(%rip), %rsi      # 0x1bd60
leaq 0xc013(%rip), %rdx      # 0x1bd70
xorl %eax, %eax
movl %eax, %ecx
callq 0x3210
movq %rax, -0x90(%rbp)
jmp 0xfd91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3130
jmp 0xfdcc
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0xfd91
movq -0x90(%rbp), %rax
cmpq $0x0, %rax
je 0xfda4
movb $0x1, -0x1(%rbp)
jmp 0xfdbe
movb $0x0, -0x1(%rbp)
jmp 0xfdbe
jmp 0xfdac
leaq -0x28(%rbp), %rdi
callq 0xdb00
jmp 0xfcdd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xda70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdaa0
testb $0x1, %al
jne 0xfe30
jmp 0xfea5
leaq -0x28(%rbp), %rdi
callq 0xdae0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xeb30
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3040
movl %eax, -0x74(%rbp)
jmp 0xfe63
leaq -0x58(%rbp), %rdi
callq 0x3130
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
jne 0xfe95
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfead
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3130
jmp 0xfeba
jmp 0xfe97
leaq -0x28(%rbp), %rdi
callq 0xdb00
jmp 0xfe1d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3300
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x42c6
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x42b9
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x42ac
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x42ae
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x427b
jmp 0x42bb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x425d
movq -0x40(%rbp), %rax
movl $0x0, -0x2c(%rbp)
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4316
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x30(%rbp), %eax
jle 0x4309
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
jmp 0x430b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x42dd
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x43ab
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4352
movsd -0x20(%rbp), %xmm0
callq 0x3190
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movb $0x1, -0x2d(%rbp)
movb $0x0, -0x2e(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4481
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x4410
jp 0x4410
movb $0x1, -0x2e(%rbp)
testb $0x1, -0x2e(%rbp)
je 0x446f
movb $0x1, -0x2d(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x445f
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x2d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x2d(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4421
testb $0x1, -0x2d(%rbp)
je 0x446d
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x44a0
jmp 0x446f
movb $0x0, -0x2e(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x43ea
movq 0x14b40(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xc024(%rip), %rsi      # 0x104b6
movb $0x0, %al
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x12ef
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x1c30
movq %rax, %rdi
callq 0x1c00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x1c30
movq %rax, %rdi
callq 0x1c50
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
xorl %edx, %edx
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1307
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x1300
movl $0x1, -0x4(%rbp)
jmp 0x1307
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: BelfordZ[P]SimpleFileServer/ClientApplication.cpp
// Function: main
int main() {
   std::string fileName;// = "text.txt";

  Client c(0);

  std::cout << "File to retrieve: ";
  std::cin >> fileName;

  c.connect(fileName);
  c.listen();
  c.write_file();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33c0
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x3e10
jmp 0x39f8
movq 0x85d1(%rip), %rdi      # 0xbfd0
leaq 0x4608(%rip), %rsi      # 0x800e
callq 0x3280
jmp 0x3a0d
movq 0x85cc(%rip), %rdi      # 0xbfe0
leaq -0x28(%rbp), %rsi
callq 0x3380
jmp 0x3a1f
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3e90
jmp 0x3a2e
leaq -0x70(%rbp), %rdi
callq 0x4b30
jmp 0x3a39
leaq -0x70(%rbp), %rdi
callq 0x52c0
jmp 0x3a44
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3b50
leaq -0x28(%rbp), %rdi
callq 0x3518
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x3a8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3b50
leaq -0x28(%rbp), %rdi
callq 0x3518
movq -0x78(%rbp), %rdi
callq 0x3460
nop
// File: BelfordZ[P]SimpleFileServer/Client.cpp
// Function: Client::Client(int)
Client::Client(int pid) {
   clientPID = pid;
   framesRemaining = 0;
   lineBuffer = "";
   previousLineLength = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq %rdi, -0x28(%rbp)
callq 0x33c0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, (%rax)
leaq 0x4488(%rip), %rsi      # 0x82d7
callq 0x33b0
jmp 0x3e56
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3518
movq -0x18(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Client.cpp
// Function: Client::receive_frame()
Frame Client::receive_frame() {
   std::string receivedString = "";

   // Wait for the server to send us data: if the socket is empty, we need to wait
   sktIn->recv(receivedString);
   Frame receivedFrame(receivedString); // Create a frame from our raw data    
   return receivedFrame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3470
movq -0x50(%rbp), %rdx
leaq 0x396c(%rip), %rsi      # 0x82d7
leaq -0x30(%rbp), %rdi
callq 0x3aa0
jmp 0x4976
leaq -0x31(%rbp), %rdi
callq 0x32f0
movq -0x58(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7a50
jmp 0x4992
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x5990
jmp 0x49a5
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x49e8
jmp 0x49df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32f0
jmp 0x49fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3518
jmp 0x49fb
movq -0x68(%rbp), %rdi
callq 0x54a0
leaq -0x30(%rbp), %rdi
callq 0x3518
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Client.cpp
// Function: Client::transfer_stats(int, int) const
void Client::transfer_stats(int totalFrames, int badFrames) const {
   std::cout << "--------------------[  END TRANSMISSION  ]--------------------" << std::endl
	     << " Transfer statistics: " << std::endl
	     << "\tTotal Frames Received:\t\t" << totalFrames << std::endl
	     << "\tGood Frames Received:\t\t" << totalFrames-badFrames << std::endl
	     << "\tDamaged Frames Received:\t" << badFrames << std::endl
	     << "\tGood-Damaged Frame Ratio:\t" << (totalFrames-badFrames)/badFrames << ":1" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x6e17(%rip), %rdi      # 0xbfd0
leaq 0x308f(%rip), %rsi      # 0x824f
callq 0x3280
movq %rax, %rdi
movq 0x6de9(%rip), %rsi      # 0xbfb8
callq 0x32d0
movq %rax, %rdi
leaq 0x30b0(%rip), %rsi      # 0x828e
callq 0x3280
movq %rax, %rdi
movq 0x6dcb(%rip), %rsi      # 0xbfb8
callq 0x32d0
movq %rax, %rdi
leaq 0x30a9(%rip), %rsi      # 0x82a5
callq 0x3280
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3450
movq %rax, %rdi
movq 0x6da2(%rip), %rsi      # 0xbfb8
callq 0x32d0
movq %rax, %rdi
leaq 0x309a(%rip), %rsi      # 0x82bf
callq 0x3280
movq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x10(%rbp), %esi
callq 0x3450
movq %rax, %rdi
movq 0x6d76(%rip), %rsi      # 0xbfb8
callq 0x32d0
movq %rax, %rdi
leaq 0x3087(%rip), %rsi      # 0x82d8
callq 0x3280
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3450
movq %rax, %rdi
movq 0x6d4d(%rip), %rsi      # 0xbfb8
callq 0x32d0
movq %rax, %rdi
leaq 0x3079(%rip), %rsi      # 0x82f3
callq 0x3280
movq %rax, %rdi
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %eax, %esi
callq 0x3450
movq %rax, %rdi
leaq 0x3072(%rip), %rsi      # 0x830f
callq 0x3280
movq %rax, %rdi
movq 0x6d0c(%rip), %rsi      # 0xbfb8
callq 0x32d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movb %dl, %al
movl 0x40(%rsp), %edx
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x40(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x169a6
movq (%rsp), %rdi
addq $0x4, %rdi
movslq 0x14(%rsp), %rax
imulq $0x49c, %rax, %rax      # imm = 0x49C
addq %rax, %rdi
movslq 0xc(%rsp), %rax
imulq $0x74, %rax, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x135c0
movq 0x18(%rsp), %rdi
callq 0x13370
movq %rax, %rcx
movq (%rsp), %rax
addq $0x4, %rax
movslq 0x14(%rsp), %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rax
movslq 0xc(%rsp), %rdx
imulq $0x74, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x64(%rax)
cmpl $0x6c, 0x24(%rsp)
je 0x169d7
movq (%rsp), %rax
movl 0x24(%rsp), %ecx
addq $0x4, %rax
movslq 0x14(%rsp), %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rax
movslq 0xc(%rsp), %rdx
imulq $0x74, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x68(%rax)
cmpl $0x6c, 0x20(%rsp)
je 0x16a08
movq (%rsp), %rax
movl 0x20(%rsp), %ecx
addq $0x4, %rax
movslq 0x14(%rsp), %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rax
movslq 0xc(%rsp), %rdx
imulq $0x74, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x6c(%rax)
movq (%rsp), %rax
movl 0x40(%rsp), %edx
movq %rax, %rcx
addq $0x4, %rcx
movslq 0x14(%rsp), %rsi
imulq $0x49c, %rsi, %rsi      # imm = 0x49C
addq %rsi, %rcx
movslq 0xc(%rsp), %rsi
imulq $0x74, %rsi, %rsi
addq %rsi, %rcx
movl %edx, 0x70(%rcx)
movb 0x2b(%rsp), %cl
addq $0x4, %rax
movslq 0x14(%rsp), %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x48c(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: AutomataLab[P]JSONSki/src/./lib/QueryAutomaton.h
// Function: QueryAutomaton::addIndexConstraints(int, int, int)
void addIndexConstraints(int state, int start_idx, int end_idx) {
        if (state != UNMATCHED_STATE) {
            mDfa.trans_ele[state - 1].has_index_constraint = true;
            mDfa.trans_ele[state - 1].start_idx = start_idx;
            mDfa.trans_ele[state - 1].end_idx = end_idx;
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0xc(%rsp)
je 0x16af0
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movl -0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rcx
movb $0x1, 0x498(%rcx)
movl -0x10(%rsp), %edx
movq %rax, %rcx
addq $0x4, %rcx
movl -0xc(%rsp), %esi
subl $0x1, %esi
movslq %esi, %rsi
imulq $0x49c, %rsi, %rsi      # imm = 0x49C
addq %rsi, %rcx
movl %edx, 0x490(%rcx)
movl -0x14(%rsp), %ecx
addq $0x4, %rax
movl -0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rax
movl %ecx, 0x494(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x6e0, %rdi            # imm = 0x6E0
movq %rdi, 0x8(%rsp)
callq 0x623b0
movq 0x10(%rsp), %rdi
addq $0xef00, %rdi           # imm = 0xEF00
movq %rdi, 0x18(%rsp)
callq 0xd2dc0
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xd5660
jmp 0x16b55
movq 0x10(%rsp), %rsi
addq $0x6e0, %rsi            # imm = 0x6E0
leaq 0x38(%rsp), %rdi
callq 0x16350
jmp 0x16b6d
leaq 0x38(%rsp), %rdi
callq 0xd2ed0
movq 0x10(%rsp), %rdi
addq $0xef00, %rdi           # imm = 0xEF00
callq 0xd33d0
movq 0x10(%rsp), %rax
movq $0x0, 0xeef8(%rax)
movl $0x2710, %edi           # imm = 0x2710
callq 0x647f0
movq %rax, (%rsp)
jmp 0x16ba8
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x6d0(%rdi)
callq 0x16c10
jmp 0x16bbf
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x16bec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd2ed0
movq 0x18(%rsp), %rdi
callq 0xd2ed0
movq 0x8(%rsp), %rdi
callq 0x623f0
movq 0x30(%rsp), %rdi
callq 0x13710
nopw (%rax,%rax)
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, 0x2c8(%rax)
movq -0x18(%rsp), %rcx
movq %rcx, 0x2d0(%rax)
movq -0x18(%rsp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x2d8(%rax)
movq -0x18(%rsp), %rax
movl $0x40, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x2e0(%rax)
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
vmovaps 0xa0(%rax), %ymm1
vmovaps 0x160(%rax), %ymm0
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movq %rcx, 0x8(%rsp)
vmovaps 0xc0(%rax), %ymm1
vmovaps 0x160(%rax), %ymm0
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movl %ecx, %ecx
movq %rcx, (%rsp)
movq (%rsp), %rdx
shlq $0x20, %rdx
orq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq (%rax), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
vmovaps 0xa0(%rax), %ymm1
vmovaps 0x1e0(%rax), %ymm0
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movq %rcx, 0x8(%rsp)
vmovaps 0xc0(%rax), %ymm1
vmovaps 0x1e0(%rax), %ymm0
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movl %ecx, %ecx
movq %rcx, (%rsp)
movq (%rsp), %rdx
shlq $0x20, %rdx
orq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
vmovaps 0xa0(%rax), %ymm1
vmovaps 0x200(%rax), %ymm0
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movq %rcx, 0x8(%rsp)
vmovaps 0xc0(%rax), %ymm1
vmovaps 0x200(%rax), %ymm0
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movl %ecx, %ecx
movq %rcx, (%rsp)
movq (%rsp), %rdx
shlq $0x20, %rdx
orq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rdx, 0x20(%rcx)
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
vmovaps 0xa0(%rax), %ymm1
vmovaps 0x220(%rax), %ymm0
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movq %rcx, 0x8(%rsp)
vmovaps 0xc0(%rax), %ymm1
vmovaps 0x220(%rax), %ymm0
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpcmpeqb %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %ymm0
vpmovmskb %ymm0, %ecx
movl %ecx, %ecx
movq %rcx, (%rsp)
movq (%rsp), %rdx
shlq $0x20, %rdx
orq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rdx, 0x28(%rcx)
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x62400
movq 0x48(%rsp), %rax
movq (%rax), %rax
movl $0x40, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rsp), %rcx
subq $0x1, %rcx
xorq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x19ef0
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rdx
xorl %ecx, %ecx
subq (%rdx), %rcx
andq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
subq 0x30(%rsp), %rax
orq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x58(%rsp)
movb $0x1, 0x60(%rsp)
jmp 0x19f2e
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
subq 0x30(%rsp), %rax
orq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x58(%rsp)
movb $0x0, 0x60(%rsp)
movq 0x58(%rsp), %rax
movb 0x60(%rsp), %dl
addq $0x68, %rsp
retq
nopl (%rax)
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::get_interval_new_word(unsigned long&)
__attribute__((always_inline)) IntervalInfo QueryProcessor::get_interval_new_word(unsigned long& bitmap) {
    IntervalInfo itv_info;
    unsigned long w_start = 1;
    if (bitmap) {
        unsigned long w_end = bitmap & (-bitmap);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval;
        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;
        itv_info.is_complete = false;
    }
    return itv_info;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x62400
movq $0x1, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x19fab
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
subq (%rdx), %rcx
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
orq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x1, 0x40(%rsp)
jmp 0x19fdb
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
subq 0x20(%rsp), %rax
orq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
movq 0x38(%rsp), %rax
movb 0x40(%rsp), %dl
addq $0x48, %rsp
retq
nopl (%rax)
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::next_interval(unsigned long&)
__attribute__((always_inline)) IntervalInfo QueryProcessor::next_interval(unsigned long& bitmap) {
    IntervalInfo itv_info;
    unsigned long w_start = bitmap & (-bitmap);
    bitmap = bitmap & (bitmap - 1);
    if (bitmap) {
        unsigned long w_end = bitmap & (-bitmap);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval;
        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;
        itv_info.is_complete = false;
    }
    return itv_info;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x62400
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
subq (%rdx), %rcx
andq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
andq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1a08b
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
subq (%rdx), %rcx
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
orq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x1, 0x40(%rsp)
jmp 0x1a0bb
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
subq 0x20(%rsp), %rax
orq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
movq 0x38(%rsp), %rax
movb 0x40(%rsp), %dl
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpl $0x1, -0x14(%rsp)
jle 0x1a11b
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
andq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1a0e8
movq -0x28(%rsp), %rax
movq 0x270(%rax), %rax
shlq $0x6, %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
tzcntq %rcx, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopl (%rax)