LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::getVictimFrameNotInSet(std::__cxx11::list<Address, std::allocator<Address>> const&)
Address **InvertedPageTable::getVictimFrameNotInSet(const list<Address>& workingSet) {
	for (int frame = 0 ; frame < invertedPageTableSize ; frame++) {
		if (find(workingSet.begin(), workingSet.end(), *invertedPageTable[frame]) == workingSet.end()) {
			return &invertedPageTable[frame];
		}
	}
	return NULL;
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
jle 0x3d13
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
movq (%r15), %rbx
cmpq %r15, %rbx
je 0x3cfe
movq (%r14), %rax
movq (%rax,%r13,8), %r12
leaq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x3596
testb %al, %al
jne 0x3cfe
movq (%rbx), %rbx
cmpq %r15, %rbx
jne 0x3ce6
cmpq %r15, %rbx
je 0x3d16
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x3cd7
xorl %eax, %eax
jmp 0x3d20
xorl %eax, %eax
retq
shlq $0x3, %r13
addq (%r14), %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::print() const
void InvertedPageTable::print() const {
	cout << "\n~~~ InvertedPageTable ~~~\n";
	for (int frame = 0 ; frame < invertedPageTableSize ; frame++ ) {
		if (invertedPageTable[frame] == NULL) {
			cout << "NULL" << endl;
		}
		else {
			cout << invertedPageTable[frame]->toString() << endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x428d(%rip), %r14      # 0x7fd8
leaq 0x15b7(%rip), %rsi      # 0x5309
movl $0x1b, %edx
movq %r14, %rdi
callq 0x21c0
cmpl $0x0, 0x8(%rbx)
jle 0x3e1f
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
movq (%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0x3dd4
movq (%rax,%r15,8), %rsi
movq %r12, %rdi
callq 0x35ac
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x21c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e0f
callq 0x2160
jmp 0x3e0f
movl $0x4, %edx
movq %r14, %rdi
leaq 0x1542(%rip), %rsi      # 0x5325
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x3d70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e43
callq 0x2160
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Paging-Simulator/WorkingSet.cpp
// Function: WorkingSet::update(Address const&, Address**)
void WorkingSet::update(const Address& address, Address **victimAddress) {
	if (this->recentListIsFull()) {
		*victimAddress = new Address(recentList.front()); // Oldest page
		recentList.pop_front();
		if (find(recentList.begin(), recentList.end(), **victimAddress) == recentList.end()) {
			workingSet.remove(**victimAddress);
		}
		else {
			delete *victimAddress;
			*victimAddress = NULL;
		}
	}
	/* Include newcomer */
	recentList.push_back(address);
	if (find(workingSet.begin(), workingSet.end(), address) == workingSet.end()) {
		/* No duplicates in working SET */
		workingSet.push_back(address);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x30(%rdi), %rax
movq 0x10(%rdi), %r13
cmpq %rax, %r13
jne 0x41c6
movq %rdx, %r15
movl $0xc, %edi
callq 0x2190
movq (%rbx), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq %rax, (%r15)
movq (%rbx), %r12
decq %r13
movq %r13, 0x10(%rbx)
movq %r12, %rdi
callq 0x2250
movq %r12, %rdi
callq 0x2160
movq (%rbx), %r13
cmpq %rbx, %r13
je 0x419f
movq (%r15), %r12
leaq 0x10(%r13), %rdi
movq %r12, %rsi
callq 0x3596
testb %al, %al
jne 0x419f
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x4186
cmpq %rbx, %r13
je 0x41ba
movq (%r15), %rdi
testq %rdi, %rdi
je 0x41b1
callq 0x2160
movq $0x0, (%r15)
jmp 0x41c6
leaq 0x18(%rbx), %rdi
movq (%r15), %rsi
callq 0x4496
movl $0x20, %edi
callq 0x2190
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
incq 0x10(%rbx)
leaq 0x18(%rbx), %r15
movq 0x18(%rbx), %r12
cmpq %r15, %r12
je 0x4211
leaq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x3596
testb %al, %al
jne 0x4211
movq (%r12), %r12
jmp 0x41f5
cmpq %r15, %r12
jne 0x423d
movl $0x20, %edi
callq 0x2190
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
incq 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iPapatsoris[P]Paging-Simulator/WorkingSet.cpp
// Function: WorkingSet::print() const
void WorkingSet::print() const {
	cout << "\n=== Recent List === " << endl;
	for (list<Address>::const_iterator it = recentList.begin() ; it != recentList.end() ; it++) {
		cout << (*it).toString() << endl;
	}
	cout << "=== Working Set === " << endl;
	for (list<Address>::const_iterator it = workingSet.begin() ; it != workingSet.end() ; it++) {
		cout << (*it).toString() << endl;
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x3d55(%rip), %rbx      # 0x7fd8
leaq 0x10a0(%rip), %rsi      # 0x532a
movl $0x15, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq (%r14), %rbx
cmpq %r14, %rbx
je 0x4331
leaq -0x48(%rbp), %r15
movq 0x3d07(%rip), %r12      # 0x7fd8
leaq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x35ac
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x21c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4329
callq 0x2160
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x42d1
leaq 0x1008(%rip), %rsi      # 0x5340
movl $0x14, %edx
movq 0x3c94(%rip), %rbx      # 0x7fd8
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq 0x18(%r14), %rbx
addq $0x18, %r14
cmpq %r14, %rbx
je 0x43eb
leaq -0x48(%rbp), %r15
movq 0x3c4d(%rip), %r12      # 0x7fd8
leaq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x35ac
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x21c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x43e3
callq 0x2160
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x438b
movq 0x3be6(%rip), %rbx      # 0x7fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x442a
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x443f
callq 0x2160
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::get(PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path)
Convertor
PTree<Key>::get(Path path) {
    std::string p = path.pop();
    typename TreeType::iterator it = data_.find(p);
    if (it != data_.end()) {
        if (path.empty()) {
            return Convertor(it->second);
        } else {
            PTree* child = boost::any_cast<PTree>(&(it->second));
            if (child) {
                return child->get(path);
            } else {
                throw PTreeBadPath("invalid path");
            }
        }

    } else {
        throw PTreeBadPath("path not found");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4a26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5d66
movq %rax, %rbx
addq $0x8, %r15
cmpq %r15, %rax
je 0x35fc
movq 0x30(%r14), %rax
addq $0x40, %rbx
cmpq 0x10(%r14), %rax
je 0x35d0
movq %rbx, %rdi
callq 0x4b24
testq %rax, %rax
je 0x365e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x541e
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3550
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46de
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35eb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c79(%rip), %rsi      # 0x7292
leaq 0x3c80(%rip), %rdx      # 0x72a0
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x7597(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x7563(%rip), %rsi      # 0xabb0
movq 0x7974(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x36be
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c0a(%rip), %rsi      # 0x7285
leaq 0x3c0f(%rip), %rdx      # 0x7291
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x7535(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x7501(%rip), %rsi      # 0xabb0
movq 0x7912(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x36c2
jmp 0x36de
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x36e4
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3707
movq %r14, %rdi
callq 0x2130
jmp 0x3707
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46de
jmp 0x3707
jmp 0x3704
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3722
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./Convertors.h
// Function: Convertor::operator std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>()
operator T&() {
        T* v = boost::any_cast<T>(&data_);
        if (v) {
            return *v;
        } else {
            throw PTreeBadType("cast error");
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rdi
callq 0x5dc3
testq %rax, %rax
je 0x374c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3b3e(%rip), %rsi      # 0x72a7
leaq 0x3b41(%rip), %rdx      # 0x72b1
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x7487(%rip), %rax      # 0xac18
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x7453(%rip), %rsi      # 0xabf0
movq 0x7824(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x37ce
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x37db
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::isValidPath(PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path) const
bool
PTree<Key>::isValidPath(Path path) const {
    std::string p = path.pop();
    typename TreeType::const_iterator it = data_.find(p);
    if (it != data_.end()) {
        if (path.empty()) {
            return true;
        } else {
            const PTree* child = boost::any_cast<PTree>(&(it->second));
            if (child) {
                return child->isValidPath(path);
            } else {
                return false;
            }
        }
    } else {
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x4a26
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e38
addq $0x8, %r14
cmpq %r14, %rax
je 0x38b2
movq 0x30(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
je 0x38b6
addq $0x40, %rax
movq %rax, %rdi
callq 0x4b24
testq %rax, %rax
je 0x38b2
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x541e
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x383e
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x46de
jmp 0x38b8
xorl %ebx, %ebx
jmp 0x38b8
movb $0x1, %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x46de
jmp 0x38f3
jmp 0x38f0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x390e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::get(PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path) const
ConstConvertor
PTree<Key>::get(Path path) const {
    std::string p = path.pop();
    typename TreeType::const_iterator it = data_.find(p);
    if (it != data_.end()) {
        if (path.empty()) {
            return ConstConvertor(it->second);
        } else {
            const PTree* child = boost::any_cast<PTree>(&(it->second));
            if (child) {
                return child->get(path);
            } else {
                throw PTreeBadPath("invalid path");
            }
        }

    } else {
        throw PTreeBadPath("path not found");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4a26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5e38
movq %rax, %rbx
addq $0x8, %r15
cmpq %r15, %rax
je 0x39c2
movq 0x30(%r14), %rax
addq $0x40, %rbx
cmpq 0x10(%r14), %rax
je 0x3996
movq %rbx, %rdi
callq 0x4b24
testq %rax, %rax
je 0x3a24
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x541e
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3916
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46de
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39b1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x38b3(%rip), %rsi      # 0x7292
leaq 0x38ba(%rip), %rdx      # 0x72a0
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x71d1(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x719d(%rip), %rsi      # 0xabb0
movq 0x75ae(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x3a84
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3844(%rip), %rsi      # 0x7285
leaq 0x3849(%rip), %rdx      # 0x7291
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x716f(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x713b(%rip), %rsi      # 0xabb0
movq 0x754c(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x3a88
jmp 0x3aa4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3aaa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x3aaa
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3acd
movq %r14, %rdi
callq 0x2130
jmp 0x3acd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46de
jmp 0x3acd
jmp 0x3aca
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ae8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./Convertors.h
// Function: ConstConvertor::operator std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const
operator T&() const {
        const T* cv = boost::any_cast<T>(&data_);
        // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#976
        T* v = const_cast<T*>(cv);
        if (v) {
            return *v;
        } else {
            throw PTreeBadType("const cast error");
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rdi
callq 0x5dc3
testq %rax, %rax
je 0x3b12
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3772(%rip), %rsi      # 0x72a1
leaq 0x377b(%rip), %rdx      # 0x72b1
leaq 0x8(%rsp), %rdi
callq 0x4906
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x70c1(%rip), %rax      # 0xac18
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x708d(%rip), %rsi      # 0xabf0
movq 0x745e(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b94
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x3b94
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3ba1
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path::pop()
std::string
PTree<Key>::Path::pop() {
    if (p_.empty()) {
        return std::string();
    } else {
        std::string s = p_.front();
        p_.pop();
        return s;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rax, 0x30(%rsi)
movq %rcx, (%rdi)
je 0x4a5d
movq %rsi, %r14
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4996
movq %r14, %rdi
callq 0x4bcc
jmp 0x4a69
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path::Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PTree<Key>::Path::Path(const std::string& path) {
    std::string::size_type start = 0;
    while (start < path.size()) {
        std::string::size_type pos = path.find(".", start);
        if (pos == std::string::npos) {
            pos = path.size();
        }
        p_.push(path.substr(start, pos - start));
        start = pos + 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0x54ea
cmpq $0x0, 0x8(%r14)
je 0x5941
xorl %ebp, %ebp
leaq 0x197e(%rip), %r15      # 0x7253
leaq 0x8(%rsp), %r12
movl $0x1, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2270
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x58fa
movq 0x8(%r14), %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x21b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5984
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5935
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
incq %r13
movq %r13, %rbp
cmpq 0x8(%r14), %r13
jb 0x58da
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5974
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5974
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x46de
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/genpattern.cpp
// Function: qrmload(int, int)
int qrmload(int c,int jo){
    char chr;FILE *fp;
    long long int qsize = std::filesystem::file_size(fname);
    fp = fopen(fname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s doesn't exist!\n", fname);
        exit(2);return -1;}
    int rlen = rand()%(qsize-c);
    fseek(fp,rlen,SEEK_SET);
    for(int i=0;i<c;i++) {
        chr = fgetc(fp);
        ptlist[jo][i] = chr;
        if(chr<0){ptlist[jo][i]=chr + 256;}}
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x2e43(%rip), %rsi      # 0x4148
movq %rsp, %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x179e
movq %r14, %rdi
callq 0x1150
movq %rax, %r15
movq %rsp, %rdi
callq 0x1826
movq 0x2e19(%rip), %rdi      # 0x4148
leaq 0xcce(%rip), %rsi       # 0x2004
callq 0x1110
testq %rax, %rax
je 0x13a4
movq %rax, %r14
callq 0x1060
cltq
movslq %ebx, %r12
subq %r12, %r15
cqto
idivq %r15
movq %r14, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x1100
testl %r12d, %r12d
jle 0x1393
movslq %ebp, %rax
movl %ebx, %ebx
imulq $0x64, %rax, %r15
xorl %r12d, %r12d
leaq 0x2de6(%rip), %r13      # 0x4160
movq %r14, %rdi
callq 0x1190
leaq (%r15,%r12), %rcx
movb %al, (%r13,%rcx)
incq %r12
cmpq %r12, %rbx
jne 0x137a
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d9d(%rip), %rsi      # 0x4148
leaq 0xc54(%rip), %rdi       # 0x2006
xorl %eax, %eax
callq 0x1030
movl $0x2, %edi
callq 0x1120
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1826
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/genpattern.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead <inputfile> and make <queryfile>. \n");
    printf(": ./genpattern -i <inputfile>\n");
    printf("\nYou can set the name of output by using option -o. \n");
    printf(": ./genpattern -i <inputfile> -o <outputfile>\n");
    printf("\nYou can set the number of query by using option -r. \n");
    printf("10 is used by default.(defined 'MREP' in this code.)\n");
    printf(": ./genpattern -i <inputfile> -o <outputfile> -r <times>\n");
    printf("\nYou can set the length of pattern by using option -l. \n");
    printf("100 is used by default.(defined 'MLONG' in this code.)\n");
    printf(": ./genpattern -i <inputfile> -o <outputfile> -l <length>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0xc93(%rip), %rdi       # 0x2071
callq 0x1180
leaq 0xca8(%rip), %rdi       # 0x2092
callq 0x1180
leaq 0xcc5(%rip), %rdi       # 0x20bb
callq 0x1180
leaq 0xcd7(%rip), %rdi       # 0x20d9
callq 0x1180
leaq 0xd00(%rip), %rdi       # 0x210e
callq 0x1180
leaq 0xd22(%rip), %rdi       # 0x213c
callq 0x1180
leaq 0xd4c(%rip), %rdi       # 0x2172
callq 0x1180
leaq 0xd75(%rip), %rdi       # 0x21a7
callq 0x1180
leaq 0xda2(%rip), %rdi       # 0x21e0
callq 0x1180
leaq 0xdce(%rip), %rdi       # 0x2218
callq 0x1180
leaq 0xdf9(%rip), %rdi       # 0x224f
callq 0x1180
movl $0xa, %edi
callq 0x1160
movl $0xa, %edi
callq 0x1160
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/moveHP.cc
// Function: main
int main()
{
	HasPtr hp("hi mom");
	HasPtr hp2(hp);
	// HasPtr hp2 = std::move(hp);
	std::cout << "===========" << std::endl;
	hp = hp2; // hp2 is an lvalue; copy constructor used to copy hp2
	std::cout << "===========" << std::endl;
	hp = std::move(hp2); // move constructor moves hp2
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd9e(%rip), %rsi       # 0x2004
leaq 0xd9d(%rip), %rdx       # 0x200a
leaq -0x30(%rbp), %rdi
callq 0x170e
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13ee
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1298
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10c0
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1494
movq 0x2d2c(%rip), %rbx      # 0x3fd8
leaq 0xd58(%rip), %rsi       # 0x200b
movl $0xb, %edx
movq %rbx, %rdi
callq 0x10d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq 0x2cfa(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1494
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x153c
leaq -0x50(%rbp), %rdi
callq 0x15b6
movq 0x2cc3(%rip), %rbx      # 0x3fd8
leaq 0xcef(%rip), %rsi       # 0x200b
movl $0xb, %edx
movq %rbx, %rdi
callq 0x10d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq 0x2c91(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x15f6
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x153c
leaq -0x60(%rbp), %rdi
callq 0x15b6
leaq -0x30(%rbp), %rdi
callq 0x15b6
leaq -0x40(%rbp), %rdi
callq 0x15b6
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x13a6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x15b6
jmp 0x13d4
movq %rax, %rbx
jmp 0x13dd
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x13e6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10c0
jmp 0x13e6
movq %rax, %rbx
jmp 0x13e6
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x15b6
leaq -0x40(%rbp), %rdi
callq 0x15b6
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/check.c
// Function: isqrt
unsigned isqrt(unsigned n)
{
	unsigned root, remain, place;

	root = 0;

	remain = n;

	place = 0x40000000;

	while (place > remain)
		place /= 4;

	while (place) {
		if (remain >= root + place) {
			remain -= root + place;
			root += 2 * place;
		}

		root /= 2;
		place /= 4;
	}

	return root;
}

// Assembly:
movl $0x40000000, %eax       # imm = 0x40000000
movl %eax, %ecx
shrl $0x2, %eax
cmpl %edi, %ecx
ja 0x1248
testl %ecx, %ecx
je 0x1283
xorl %edx, %edx
xorl %esi, %esi
leal (%rcx,%rsi), %r8d
leal (%rcx,%rcx), %eax
cmpl %r8d, %edi
cmovbl %edx, %eax
cmovbl %edx, %r8d
addl %esi, %eax
subl %r8d, %edi
shrl %eax
movl %ecx, %r8d
shrl $0x2, %r8d
movl %eax, %esi
cmpl $0x3, %ecx
movl %r8d, %ecx
ja 0x1259
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/check.c
// Function: start
void start(const char* str)
{
	cache_clear();
	compare_counter = 0;
	the_str = str;
	the_start = nano();
}

// Assembly:
movq $-0x20, %rax
leaq 0x9b5d(%rip), %rcx      # 0xae10
incb 0x20(%rax,%rcx)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x12b3
pushq %rax
movl $0x0, 0x9b32(%rip)      # 0xae00
movq %rdi, 0x1009b3b(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x1009b37(%rip)   # 0x100ae18
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/check.c
// Function: test_alloc
void test_alloc(void)
{
	const unsigned size = 10 * TOMMY_SIZE;
	unsigned i;
	tommy_allocator alloc;
	void** PTR;

	PTR = malloc(size * sizeof(void*));

	/* ensure at least pointer alignment */
	tommy_allocator_init(&alloc, sizeof(void*), 1);
	if (alloc.align_size < sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	/* ensure correct alignment */
	tommy_allocator_init(&alloc, sizeof(void*) - 1, sizeof(void*));
	if (alloc.block_size != sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	/* check big blocks */
	tommy_allocator_init(&alloc, 128000, 64);
	if (tommy_allocator_alloc(&alloc) == 0)
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	tommy_allocator_init(&alloc, 64, 64);

	START("alloc");
	for(i=0;i<size;++i) {
		PTR[i] = tommy_allocator_alloc(&alloc);
	}
	STOP();

	START("free");
	for(i=0;i<size;++i) {
		tommy_allocator_free(&alloc, PTR[i]);
	}
	STOP();

	tommy_allocator_done(&alloc);

	free(PTR);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x4c4b400, %edi        # imm = 0x4C4B400
callq 0x10c0
movq %rax, %rbx
movq %rsp, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x40e5
cmpq $0x7, 0x18(%r14)
jbe 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x4121
movl $0x7, %esi
movl $0x8, %edx
movq %r14, %rdi
callq 0x40e5
cmpq $0x8, 0x10(%r14)
jne 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x4121
movl $0x1f400, %esi          # imm = 0x1F400
movl $0x40, %edx
movq %r14, %rdi
callq 0x40e5
movq %r14, %rdi
callq 0x4157
testq %rax, %rax
je 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x4121
movl $0x40, %esi
movl $0x40, %edx
movq %r14, %rdi
callq 0x40e5
movq $-0x20, %rax
leaq 0x969c(%rip), %r15      # 0xae10
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x1774
movl $0x0, 0x9671(%rip)      # 0xae00
leaq 0x5a00(%rip), %rax      # 0x7196
movq %rax, 0x1009673(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x100966f(%rip)   # 0x100ae18
xorl %r12d, %r12d
movq %rsp, %r14
movq %r14, %rdi
callq 0x4157
movq %rax, (%rbx,%r12,8)
incq %r12
cmpq $0x989680, %r12         # imm = 0x989680
jne 0x17af
callq 0x1312
movq $-0x20, %rax
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x17d3
movl $0x0, 0x9612(%rip)      # 0xae00
leaq 0x59a7(%rip), %rax      # 0x719c
movq %rax, 0x1009614(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x1009610(%rip)   # 0x100ae18
xorl %r15d, %r15d
movq %rsp, %r14
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x41ef
incq %r15
cmpq $0x989680, %r15         # imm = 0x989680
jne 0x180e
callq 0x1312
movq %rsp, %rdi
callq 0x4121
movq %rbx, %rdi
callq 0x1030
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/check.c
// Function: test_array
void test_array(void)
{
	tommy_array array;
	tommy_uintptr_t i;
	const unsigned size = 50 * TOMMY_SIZE;

	tommy_array_init(&array);

	/* no op */
	tommy_array_grow(&array, 0);

	START("array init");
	for(i=0;i<size;++i) {
		tommy_array_grow(&array, i + 1);
		if (tommy_array_get(&array, i) != 0)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	START("array set");
	for(i=0;i<size;++i) {
		tommy_array_set(&array, i, (void*)i);
	}
	STOP();

	START("array get");
	for(i=0;i<size;++i) {
		if (tommy_array_get(&array, i) != (void*)i)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	if (tommy_array_memory_usage(&array) < size * sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */

	tommy_array_done(&array);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4207
movq %rbx, %rdi
xorl %esi, %esi
callq 0x429d
movq $-0x20, %rax
leaq 0x8aa7(%rip), %r15      # 0xae10
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x2369
movl $0x0, 0x8a7c(%rip)      # 0xae00
leaq 0x4e7e(%rip), %rax      # 0x7209
movq %rax, 0x1008a7e(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x1008a7a(%rip)   # 0x100ae18
xorl %r12d, %r12d
movq %rsp, %rbx
cmpq $0x2faf080, %r12        # imm = 0x2FAF080
je 0x23ec
leaq 0x1(%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x429d
cmpq %r12, 0x208(%rsp)
jbe 0x2508
movq %r12, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
movq (%rsp,%rax), %rax
cmpq $0x0, (%rax,%r12,8)
movq %r14, %r12
je 0x23a4
callq 0x1040
callq 0x1312
movq $-0x20, %rax
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x23f8
movl $0x0, 0x89ed(%rip)      # 0xae00
leaq 0x4dfa(%rip), %rax      # 0x7214
movq %rax, 0x10089ef(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x10089eb(%rip)   # 0x100ae18
xorl %eax, %eax
movq 0x208(%rsp), %rcx
cmpq %rax, %rcx
je 0x2508
movq %rax, %rdx
orq $0x1, %rdx
bsrq %rdx, %rdx
shll $0x3, %edx
movq (%rsp,%rdx), %rdx
movq %rax, (%rdx,%rax,8)
incq %rax
cmpq $0x2faf080, %rax        # imm = 0x2FAF080
jne 0x2437
callq 0x1312
movq $-0x20, %rax
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x246d
movl $0x0, 0x8978(%rip)      # 0xae00
leaq 0x4d8f(%rip), %rax      # 0x721e
movq %rax, 0x100897a(%rip)   # 0x100ae10
callq 0x12e3
movq %rax, 0x1008976(%rip)   # 0x100ae18
xorl %eax, %eax
movq 0x208(%rsp), %rcx
cmpq %rax, %rcx
je 0x2508
movq %rax, %rdx
orq $0x1, %rdx
bsrq %rdx, %rdx
shll $0x3, %edx
movq (%rsp,%rdx), %rdx
cmpq %rax, (%rdx,%rax,8)
jne 0x23e7
incq %rax
cmpq $0x2faf080, %rax        # imm = 0x2FAF080
jne 0x24ac
callq 0x1312
movq %rsp, %rdi
callq 0x4310
cmpq $0x17d783ff, %rax       # imm = 0x17D783FF
jbe 0x23e7
movq %rsp, %rdi
callq 0x4251
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4dfe(%rip), %rdi      # 0x730d
leaq 0x4e0a(%rip), %rsi      # 0x7320
leaq 0x4e1a(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarray.c
// Function: tommy_array_done
void tommy_array_done(tommy_array* array)
{
	tommy_uint_t i;

	tommy_free(array->bucket[0]);
	for (i = TOMMY_ARRAY_BIT; i < array->bucket_bit; ++i) {
		void** segment = array->bucket[i];
		tommy_free(&segment[(tommy_ptrdiff_t)1 << i]);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
cmpl $0x7, 0x210(%rbx)
jb 0x4295
movl $0x6, %r14d
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x210(%rbx), %eax
cmpq %rax, %r14
jb 0x426f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarray.c
// Function: tommy_array_grow
void tommy_array_grow(tommy_array* array, tommy_size_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		void** segment;

		/* allocate one more segment */
		segment = tommy_cast(void**, tommy_calloc(array->bucket_max, sizeof(void*)));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = &segment[-(tommy_ptrdiff_t)array->bucket_max];

		++array->bucket_bit;
		array->bucket_max = (tommy_size_t)1 << array->bucket_bit;
	}
}

// Assembly:
cmpq %rsi, 0x208(%rdi)
jae 0x430f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x208(%rdi)
movq 0x200(%rdi), %r15
cmpq %rsi, %r15
jae 0x4305
movl 0x210(%rbx), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x10b0
shlq $0x3, %r15
subq %r15, %rax
movl %ebp, %ecx
movq %rax, (%rbx,%rcx,8)
incl %ebp
movl $0x1, %r15d
movl %ebp, %ecx
shlq %cl, %r15
cmpq %r14, %r15
jb 0x42cc
movl %ebp, 0x210(%rbx)
movq %r15, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarrayof.c
// Function: tommy_arrayof_grow
void tommy_arrayof_grow(tommy_arrayof* array, tommy_size_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		unsigned char* segment;

		/* allocate one more segment */
		segment = tommy_cast(unsigned char*, tommy_calloc(array->bucket_max, array->element_size));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = segment - (tommy_ptrdiff_t)array->bucket_max * array->element_size;

		++array->bucket_bit;
		array->bucket_max = (tommy_size_t)1 << array->bucket_bit;
	}
}

// Assembly:
cmpq %rsi, 0x210(%rdi)
jae 0x4428
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x210(%rdi)
movq 0x208(%rdi), %r12
cmpq %rsi, %r12
jae 0x4420
movq 0x200(%rbx), %r15
movl 0x218(%rbx), %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x10b0
imulq %r15, %r12
subq %r12, %rax
movl %ebp, %ecx
movq %rax, (%rbx,%rcx,8)
incl %ebp
movl $0x1, %r12d
movl %ebp, %ecx
shlq %cl, %r12
cmpq %r14, %r12
jb 0x43e9
movl %ebp, 0x218(%rbx)
movq %r12, 0x208(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarrayblk.c
// Function: tommy_arrayblk_done
void tommy_arrayblk_done(tommy_arrayblk* array)
{
	tommy_size_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x208(%rdi)
je 0x44c3
xorl %r14d, %r14d
movq %r14, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
movq (%rbx,%rax), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq 0x208(%rbx), %r14
jb 0x449c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4251
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarrayblk.c
// Function: tommy_arrayblk_grow
void tommy_arrayblk_grow(tommy_arrayblk* array, tommy_size_t count)
{
	tommy_size_t block_max;
	tommy_size_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLK_SIZE - 1) / TOMMY_ARRAYBLK_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLK_SIZE, sizeof(void*)));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, 0x218(%rdi)
jae 0x454b
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x218(%rdi)
addq $0xfff, %rbx            # imm = 0xFFF
shrq $0xc, %rbx
movq 0x208(%rdi), %r15
cmpq %rbx, %r15
jae 0x454b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x429d
movq 0x208(%r14), %r12
movl $0x1000, %edi           # imm = 0x1000
movl $0x8, %esi
callq 0x10b0
cmpq %r15, %r12
jbe 0x4557
movq %r15, %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
shll $0x3, %ecx
movq (%r14,%rcx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x4519
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2daf(%rip), %rdi      # 0x730d
leaq 0x2dbd(%rip), %rsi      # 0x7322
leaq 0x2dcb(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarrayblkof.c
// Function: tommy_arrayblkof_done
void tommy_arrayblkof_done(tommy_arrayblkof* array)
{
	tommy_size_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x208(%rdi)
je 0x462a
xorl %r14d, %r14d
movq %r14, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
movq (%rbx,%rax), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq 0x208(%rbx), %r14
jb 0x4603
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4251
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommyarrayblkof.c
// Function: tommy_arrayblkof_grow
void tommy_arrayblkof_grow(tommy_arrayblkof* array, tommy_size_t count)
{
	tommy_size_t block_max;
	tommy_size_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLKOF_SIZE - 1) / TOMMY_ARRAYBLKOF_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLKOF_SIZE, array->element_size));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rsi, 0x220(%rdi)
jae 0x46b8
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x220(%rdi)
addq $0xfff, %rbx            # imm = 0xFFF
shrq $0xc, %rbx
movq 0x208(%rdi), %r12
cmpq %rbx, %r12
jae 0x46b8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x429d
movq 0x208(%r14), %r13
movq 0x218(%r14), %r15
movl $0x1000, %edi           # imm = 0x1000
movq %r15, %rsi
callq 0x10b0
cmpq %r12, %r13
jbe 0x46c2
movq %r12, %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
shll $0x3, %ecx
movq (%r14,%rcx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %rbx
jne 0x4688
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2c44(%rip), %rdi      # 0x730d
leaq 0x2c52(%rip), %rsi      # 0x7322
leaq 0x2c60(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommytree.c
// Function: tommy_tree_insert
void* tommy_tree_insert(tommy_tree* tree, tommy_tree_node* node, void* data)
{
	tommy_tree_node* insert = node;

	insert->data = data;
	insert->prev = 0;
	insert->next = 0;
	insert->index = 0;

	tree->root = tommy_tree_insert_node(tree->cmp, tree->root, &insert);

	if (insert == node)
		++tree->count;

	return insert->data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
movq %r15, %rdx
callq 0x4a41
movq %rax, (%rbx)
movq (%r15), %rax
cmpq %r14, %rax
jne 0x4a33
incq 0x10(%rbx)
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommytrie.c
// Function: tommy_trie_insert
void tommy_trie_insert(tommy_trie* trie, tommy_trie_node* node, void* data, tommy_key_t key)
{
	tommy_trie_node** let_ptr;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_BUCKET_SHIFT < TOMMY_TRIE_BUCKET_MAX);

	node->data = data;
	node->index = key;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	trie_bucket_insert(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	++trie->count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rax
shrq $0x20, %rax
jne 0x4e5f
movq %rcx, %r15
movq %rdi, %rbx
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rcx, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %r14
movq (%r14), %r13
testq %r13, %r13
je 0x4e3b
movl $0x1b, %ebp
testb $0x1, %r13b
je 0x4d56
movq %r13, %rdx
movq %r15, %rax
movl %ebp, %ecx
shrq %cl, %rax
andl $0x7, %eax
movl %eax, %ecx
movq -0x1(%rdx,%rcx,8), %r13
movq %rdx, %rcx
decq %rcx
testq %r13, %r13
je 0x4dcf
addl $-0x3, %ebp
movq %r13, %rdx
testb $0x1, %r13b
jne 0x4d25
leaq (%rcx,%rax,8), %r14
cmpq %r15, 0x18(%r13)
jne 0x4d78
movq 0x8(%r13), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r13)
movq $0x0, (%rsi)
movq 0x8(%rsi), %r14
jmp 0x4e46
movq %rsi, (%rsp)
movq 0x110(%rbx), %rdi
callq 0x4157
movq %rax, %r12
incq 0x108(%rbx)
incq %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x18(%r13), %r14
movl %ebp, %ecx
shrq %cl, %r14
movq %r15, %rdx
shrq %cl, %rdx
movl %r14d, %eax
xorl %edx, %eax
testb $0x7, %al
je 0x4dd5
movq %r12, %rax
jmp 0x4e28
leaq (%rcx,%rax,8), %r14
jmp 0x4e3b
addl $-0x3, %ebp
andl $0x7, %r14d
movq 0x110(%rbx), %rdi
callq 0x4157
xorps %xmm0, %xmm0
incq 0x108(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, (%r12,%r14,8)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x18(%r13), %r14
movl %ebp, %ecx
shrq %cl, %r14
movq %r15, %rdx
shrq %cl, %rdx
movl %r14d, %ecx
xorl %edx, %ecx
addl $-0x3, %ebp
movq %rax, %r12
testb $0x7, %cl
je 0x4dd8
andl $0x7, %r14d
movq %r13, (%rax,%r14,8)
andl $0x7, %edx
leaq (%rax,%rdx,8), %r14
movq (%rsp), %rsi
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
movq %rsi, (%r14)
incq 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26fa(%rip), %rdi      # 0x7560
leaq 0x272a(%rip), %rsi      # 0x7597
leaq 0x2737(%rip), %rcx      # 0x75ab
movl $0x9e, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommytrie.c
// Function: tommy_trie_remove
void* tommy_trie_remove(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* ret;
	tommy_trie_node** let_ptr;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_BUCKET_SHIFT < TOMMY_TRIE_BUCKET_MAX);

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, 0, key);

	if (!ret)
		return 0;

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x4ec1
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x4ee0
testq %rax, %rax
je 0x4eb6
decq 0x100(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2698(%rip), %rdi      # 0x7560
leaq 0x26c8(%rip), %rsi      # 0x7597
leaq 0x2722(%rip), %rcx      # 0x75f8
movl $0x105, %edx            # imm = 0x105
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/amadvance[P]tommyds/tommyds/tommytrie.c
// Function: tommy_trie_remove_existing
void* tommy_trie_remove_existing(tommy_trie* trie, tommy_trie_node* node)
{
	tommy_trie_node* ret;
	tommy_key_t key = node->index;
	tommy_trie_node** let_ptr;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_BUCKET_SHIFT < TOMMY_TRIE_BUCKET_MAX);

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	/* the element removed must match the one passed */
	assert(ret == node);

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rsi), %rcx
movq %rcx, %rax
shrq $0x20, %rax
jne 0x5048
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x4ee0
cmpq %r14, %rax
jne 0x5067
decq 0x100(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2511(%rip), %rdi      # 0x7560
leaq 0x2541(%rip), %rsi      # 0x7597
leaq 0x25ce(%rip), %rcx      # 0x762b
movl $0x11a, %edx            # imm = 0x11A
callq 0x1090
leaq 0x25ff(%rip), %rdi      # 0x766d
leaq 0x2522(%rip), %rsi      # 0x7597
leaq 0x25af(%rip), %rcx      # 0x762b
movl $0x121, %edx            # imm = 0x121
callq 0x1090