LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
jle 0x3ceb
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r15), %r13
cmpq %r15, %r13
je 0x3cef
movq (%r14), %rax
movq (%rax,%rbx,8), %r12
leaq 0x10(%r13), %rdi
movq %r12, %rsi
callq 0x3572
testb %al, %al
jne 0x3cda
movq (%r13), %r13
cmpq %r15, %r13
jne 0x3cbf
jmp 0x3cef
cmpq %r15, %r13
je 0x3cef
incq %rbx
movslq 0x8(%r14), %rax
cmpq %rax, %rbx
jl 0x3cb0
xorl %ebx, %ebx
jmp 0x3cf6
shlq $0x3, %rbx
addq (%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42b5(%rip), %r14      # 0x7fd8
leaq 0x15cf(%rip), %rsi      # 0x52f9
movl $0x1b, %edx
movq %r14, %rdi
callq 0x21c0
cmpl $0x0, 0x8(%rbx)
jle 0x3df5
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x3daa
movq %r12, %rdi
callq 0x3588
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 0x3de5
callq 0x2160
jmp 0x3de5
movl $0x4, %edx
movq %r14, %rdi
leaq 0x155c(%rip), %rsi      # 0x5315
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 0x3d48
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 0x3e19
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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), %r13
cmpq %r13, 0x10(%rdi)
jne 0x41ac
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 0x2240
movq %r12, %rdi
callq 0x2160
movq (%rbx), %r13
cmpq %rbx, %r13
je 0x41a0
movq (%r15), %r12
leaq 0x10(%r13), %rdi
movq %r12, %rsi
callq 0x3572
testb %al, %al
jne 0x418a
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x416f
jmp 0x41a0
cmpq %rbx, %r13
je 0x41a0
movq (%r15), %rdi
callq 0x2160
movq $0x0, (%r15)
jmp 0x41ac
leaq 0x18(%rbx), %rdi
movq (%r15), %rsi
callq 0x447c
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 0x41fc
leaq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x3572
testb %al, %al
jne 0x41f7
movq (%r12), %r12
jmp 0x41db
cmpq %r15, %r12
jne 0x4223
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_O3/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 0x3d6f(%rip), %rbx      # 0x7fd8
leaq 0x10aa(%rip), %rsi      # 0x531a
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 0x4317
leaq -0x48(%rbp), %r15
movq 0x3d21(%rip), %r12      # 0x7fd8
leaq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x3588
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 0x430f
callq 0x2160
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x42b7
leaq 0x1012(%rip), %rsi      # 0x5330
movl $0x14, %edx
movq 0x3cae(%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 0x43d1
leaq -0x48(%rbp), %r15
movq 0x3c67(%rip), %r12      # 0x7fd8
leaq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x3588
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 0x43c9
callq 0x2160
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x4371
movq 0x3c00(%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 0x4410
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4425
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49d2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5cae
movq %rax, %rbx
addq $0x8, %r15
cmpq %r15, %rax
je 0x35f0
movq 0x30(%r14), %rax
addq $0x40, %rbx
cmpq 0x10(%r14), %rax
je 0x35c4
movq %rbx, %rdi
callq 0x4ad0
testq %rax, %rax
je 0x3652
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x53c4
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3544
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4670
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35df
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 0x3c85(%rip), %rsi      # 0x7292
leaq 0x3c8c(%rip), %rdx      # 0x72a0
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x75a3(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x756f(%rip), %rsi      # 0xabb0
movq 0x7980(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x36b2
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c16(%rip), %rsi      # 0x7285
leaq 0x3c1b(%rip), %rdx      # 0x7291
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x7541(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x750d(%rip), %rsi      # 0xabb0
movq 0x791e(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x36b6
jmp 0x36d7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36d0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
testb %bpl, %bpl
jne 0x36da
jmp 0x36f8
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x36f8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4670
jmp 0x36f8
jmp 0x36f5
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3713
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d0b
testq %rax, %rax
je 0x373e
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 0x3b4c(%rip), %rsi      # 0x72a7
leaq 0x3b4f(%rip), %rdx      # 0x72b1
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x7495(%rip), %rax      # 0xac18
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x7461(%rip), %rsi      # 0xabf0
movq 0x7832(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
testb %bpl, %bpl
jne 0x37c2
jmp 0x37ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d80
addq $0x8, %r14
cmpq %r14, %rax
je 0x38a0
movq 0x30(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
je 0x38a4
addq $0x40, %rax
movq %rax, %rdi
callq 0x4ad0
testq %rax, %rax
je 0x38a0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x53c4
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x382c
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x4670
jmp 0x38a6
xorl %ebx, %ebx
jmp 0x38a6
movb $0x1, %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38c1
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 0x4670
jmp 0x38e1
jmp 0x38de
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49d2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5d80
movq %rax, %rbx
addq $0x8, %r15
cmpq %r15, %rax
je 0x39b0
movq 0x30(%r14), %rax
addq $0x40, %rbx
cmpq 0x10(%r14), %rax
je 0x3984
movq %rbx, %rdi
callq 0x4ad0
testq %rax, %rax
je 0x3a12
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x53c4
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3904
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4670
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x399f
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 0x38c5(%rip), %rsi      # 0x7292
leaq 0x38cc(%rip), %rdx      # 0x72a0
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x71e3(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x71af(%rip), %rsi      # 0xabb0
movq 0x75c0(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x3a72
movl $0x10, %edi
callq 0x20b0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3856(%rip), %rsi      # 0x7285
leaq 0x385b(%rip), %rdx      # 0x7291
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq 0x7181(%rip), %rax      # 0xabd8
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x714d(%rip), %rsi      # 0xabb0
movq 0x755e(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2260
jmp 0x3a76
jmp 0x3a97
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a90
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
testb %bpl, %bpl
jne 0x3a9a
jmp 0x3ab8
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x3ab8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4670
jmp 0x3ab8
jmp 0x3ab5
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ad3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d0b
testq %rax, %rax
je 0x3afe
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 0x3786(%rip), %rsi      # 0x72a1
leaq 0x378f(%rip), %rdx      # 0x72b1
leaq 0x8(%rsp), %rdi
callq 0x48a6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x70d5(%rip), %rax      # 0xac18
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x70a1(%rip), %rsi      # 0xabf0
movq 0x7472(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2260
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b78
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
testb %bpl, %bpl
jne 0x3b82
jmp 0x3b8a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a09
movq %rsi, %r14
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x493c
movq %r14, %rdi
callq 0x4b78
jmp 0x4a15
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_O3/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 0x548e
cmpq $0x0, 0x8(%r14)
je 0x5897
xorl %ebp, %ebp
leaq 0x1a28(%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 0x5850
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 0x58da
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x588b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
incq %r13
movq %r13, %rbp
cmpq 0x8(%r14), %r13
jb 0x5830
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x58ca
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x58ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x4670
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0xab5d(%rip), %rcx      # 0xbe10
incb 0x20(%rax,%rcx)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x12b3
pushq %rax
movl $0x0, 0xab32(%rip)      # 0xbe00
movq %rdi, 0x100ab3b(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x100ab37(%rip)   # 0x100be18
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a3
cmpq $0x7, 0x18(%r14)
jbe 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x40df
movl $0x7, %esi
movl $0x8, %edx
movq %r14, %rdi
callq 0x40a3
cmpq $0x8, 0x10(%r14)
jne 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x40df
movl $0x1f400, %esi          # imm = 0x1F400
movl $0x40, %edx
movq %r14, %rdi
callq 0x40a3
movq %r14, %rdi
callq 0x4115
testq %rax, %rax
je 0x1847
movq %rsp, %r14
movq %r14, %rdi
callq 0x40df
movl $0x40, %esi
movl $0x40, %edx
movq %r14, %rdi
callq 0x40a3
movq $-0x20, %rax
leaq 0xa69c(%rip), %r15      # 0xbe10
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x1774
movl $0x0, 0xa671(%rip)      # 0xbe00
leaq 0x5a00(%rip), %rax      # 0x7196
movq %rax, 0x100a673(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x100a66f(%rip)   # 0x100be18
xorl %r12d, %r12d
movq %rsp, %r14
movq %r14, %rdi
callq 0x4115
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, 0xa612(%rip)      # 0xbe00
leaq 0x59a7(%rip), %rax      # 0x719c
movq %rax, 0x100a614(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x100a610(%rip)   # 0x100be18
xorl %r15d, %r15d
movq %rsp, %r14
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x41ad
incq %r15
cmpq $0x989680, %r15         # imm = 0x989680
jne 0x180e
callq 0x1312
movq %rsp, %rdi
callq 0x40df
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_O3/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 0x41c5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42b6
movq $-0x20, %rax
leaq 0x9add(%rip), %r15      # 0xbe10
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x2333
movl $0x0, 0x9ab2(%rip)      # 0xbe00
leaq 0x4eb4(%rip), %rax      # 0x7209
movq %rax, 0x1009ab4(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x1009ab0(%rip)   # 0x100be18
xorl %r12d, %r12d
movq %rsp, %rbx
cmpq $0x2faf080, %r12        # imm = 0x2FAF080
je 0x23b6
leaq 0x1(%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42b6
cmpq %r12, 0x208(%rsp)
jbe 0x24d2
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 0x236e
callq 0x1040
callq 0x1312
movq $-0x20, %rax
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x23c2
movl $0x0, 0x9a23(%rip)      # 0xbe00
leaq 0x4e30(%rip), %rax      # 0x7214
movq %rax, 0x1009a25(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x1009a21(%rip)   # 0x100be18
xorl %eax, %eax
movq 0x208(%rsp), %rcx
cmpq %rax, %rcx
je 0x24d2
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 0x2401
callq 0x1312
movq $-0x20, %rax
incb 0x20(%rax,%r15)
addq $0x20, %rax
cmpq $0xffffe0, %rax         # imm = 0xFFFFE0
jb 0x2437
movl $0x0, 0x99ae(%rip)      # 0xbe00
leaq 0x4dc5(%rip), %rax      # 0x721e
movq %rax, 0x10099b0(%rip)   # 0x100be10
callq 0x12e3
movq %rax, 0x10099ac(%rip)   # 0x100be18
xorl %eax, %eax
movq 0x208(%rsp), %rcx
cmpq %rax, %rcx
je 0x24d2
movq %rax, %rdx
orq $0x1, %rdx
bsrq %rdx, %rdx
shll $0x3, %edx
movq (%rsp,%rdx), %rdx
cmpq %rax, (%rdx,%rax,8)
jne 0x23b1
incq %rax
cmpq $0x2faf080, %rax        # imm = 0x2FAF080
jne 0x2476
callq 0x1312
movq %rsp, %rdi
callq 0x4329
cmpq $0x17d783ff, %rax       # imm = 0x17D783FF
jbe 0x23b1
movq %rsp, %rdi
callq 0x426a
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4e34(%rip), %rdi      # 0x730d
leaq 0x4e40(%rip), %rsi      # 0x7320
leaq 0x4e50(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/check.c
// Function: main
int main() {
	nano_init();

	printf("Tommy check program.\n");

	test_hash();
	test_alloc();
	test_list();
	test_tree();
	test_array();
	test_arrayof();
	test_arrayblk();
	test_arrayblkof();
	test_hashtable();
	test_hashdyn();
	test_hashlin();
	test_trie();
	test_trie_inplace();

	printf("OK\n");

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rax
leaq 0x37f9(%rip), %rdi      # 0x7468
callq 0x1050
callq 0x134d
callq 0x16bb
callq 0x1881
callq 0x1f65
callq 0x2302
callq 0x24f1
callq 0x2716
callq 0x2999
callq 0x2c40
callq 0x300c
callq 0x3398
callq 0x37b3
callq 0x3a50
leaq 0x37c1(%rip), %rdi      # 0x747d
callq 0x1050
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4328
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 0x431e
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 0x42e5
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_O3/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 0x449c
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 0x4494
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 0x445d
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_O3/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 0x4592
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 0x456b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x426a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x461a
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 0x461a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42b6
movq 0x208(%r14), %r12
movl $0x1000, %edi           # imm = 0x1000
movl $0x8, %esi
callq 0x10b0
cmpq %r15, %r12
jbe 0x4626
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 0x45e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2ce0(%rip), %rdi      # 0x730d
leaq 0x2cee(%rip), %rsi      # 0x7322
leaq 0x2cfc(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4754
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 0x472d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x426a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47e2
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 0x47e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42b6
movq 0x208(%r14), %r13
movq 0x218(%r14), %r15
movl $0x1000, %edi           # imm = 0x1000
movq %r15, %rsi
callq 0x10b0
cmpq %r12, %r13
jbe 0x47ec
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 0x47b2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2b1a(%rip), %rdi      # 0x730d
leaq 0x2b28(%rip), %rsi      # 0x7322
leaq 0x2b36(%rip), %rcx      # 0x7337
movl $0x5c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5003
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 0x4fdf
movl $0x1b, %ebp
testb $0x1, %r13b
je 0x4efa
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 0x4f73
addl $-0x3, %ebp
movq %r13, %rdx
testb $0x1, %r13b
jne 0x4ec9
leaq (%rcx,%rax,8), %r14
cmpq %r15, 0x18(%r13)
jne 0x4f1c
movq 0x8(%r13), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r13)
movq $0x0, (%rsi)
movq 0x8(%rsi), %r14
jmp 0x4fea
movq %rsi, (%rsp)
movq 0x110(%rbx), %rdi
callq 0x4115
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 0x4f79
movq %r12, %rax
jmp 0x4fcc
leaq (%rcx,%rax,8), %r14
jmp 0x4fdf
addl $-0x3, %ebp
andl $0x7, %r14d
movq 0x110(%rbx), %rdi
callq 0x4115
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 0x4f7c
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 0x2586(%rip), %rdi      # 0x7590
leaq 0x25b6(%rip), %rsi      # 0x75c7
leaq 0x25c3(%rip), %rcx      # 0x75db
movl $0x9e, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5065
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x5084
testq %rax, %rax
je 0x505a
decq 0x100(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2524(%rip), %rdi      # 0x7590
leaq 0x2554(%rip), %rsi      # 0x75c7
leaq 0x25ae(%rip), %rcx      # 0x7628
movl $0x105, %edx            # imm = 0x105
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x520b
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x5084
cmpq %r14, %rax
jne 0x522a
decq 0x100(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x237e(%rip), %rdi      # 0x7590
leaq 0x23ae(%rip), %rsi      # 0x75c7
leaq 0x243b(%rip), %rcx      # 0x765b
movl $0x11a, %edx            # imm = 0x11A
callq 0x1090
leaq 0x246c(%rip), %rdi      # 0x769d
leaq 0x238f(%rip), %rsi      # 0x75c7
leaq 0x241c(%rip), %rcx      # 0x765b
movl $0x121, %edx            # imm = 0x121
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommytrie.c
// Function: tommy_trie_bucket
tommy_trie_node* tommy_trie_bucket(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* node;
	void* ptr;
	tommy_uint_t type;
	tommy_uint_t shift;

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

	ptr = trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	shift = TOMMY_TRIE_BUCKET_SHIFT;

recurse:
	if (!ptr)
		return 0;

	type = trie_get_type(ptr);

	switch (type) {
	case TOMMY_TRIE_TYPE_NODE :
		node = tommy_cast(tommy_trie_node*, ptr);
		if (node->index != key)
			return 0;
		return node;
	default :
	case TOMMY_TRIE_TYPE_TREE :
		ptr = trie_get_tree(ptr)->map[(key >> shift) & TOMMY_TRIE_TREE_MASK];
		shift -= TOMMY_TRIE_TREE_BIT;
		goto recurse;
	}
}

// Assembly:
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x5297
movq %rsi, %rax
shrq $0x1b, %rax
movq (%rdi,%rax,8), %rdx
testq %rdx, %rdx
je 0x5287
movl $0x1b, %ecx
xorl %eax, %eax
testb $0x1, %dl
je 0x528b
movq %rsi, %rdi
shrq %cl, %rdi
andl $0x7, %edi
addl $-0x3, %ecx
movq -0x1(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x526a
jmp 0x5295
xorl %eax, %eax
jmp 0x5295
xorl %eax, %eax
cmpq %rsi, 0x18(%rdx)
cmoveq %rdx, %rax
popq %rcx
retq
leaq 0x22f2(%rip), %rdi      # 0x7590
leaq 0x2322(%rip), %rsi      # 0x75c7
leaq 0x23fd(%rip), %rcx      # 0x76a9
movl $0x130, %edx            # imm = 0x130
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommytrieinp.c
// Function: tommy_trie_inplace_insert
void tommy_trie_inplace_insert(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node, void* data, tommy_key_t key)
{
	tommy_trie_inplace_node** let_ptr;
	tommy_uint_t i;

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

	node->data = data;
	node->key = key;
	/* clear the child pointers */
	for (i = 0; i < TOMMY_TRIE_INPLACE_TREE_MAX; ++i)
		node->map[i] = 0;

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	trie_inplace_bucket_insert(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

	++trie_inplace->count;
}

// Assembly:
pushq %rax
movq %rcx, %rax
shrq $0x20, %rcx
jne 0x5373
movq %rdx, 0x10(%rsi)
movq %rax, 0x38(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x28(%rsi)
movq %rax, %rcx
shrq $0x1a, %rcx
movq (%rdi,%rcx,8), %r9
testq %r9, %r9
je 0x533f
movl $0x1a, %ecx
movq %r9, %rdx
cmpq %rax, 0x38(%r9)
je 0x5350
movq %rax, %r8
shrq %cl, %r8
andl $0x3, %r8d
movl %r8d, %r9d
addl $-0x2, %ecx
movq 0x18(%rdx,%r9,8), %r9
testq %r9, %r9
jne 0x5312
addq $0x18, %rdx
leaq (%rdx,%r8,8), %rax
jmp 0x5343
leaq (%rdi,%rcx,8), %rax
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
jmp 0x5367
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%rdx)
movq $0x0, (%rsi)
movq 0x8(%rsi), %rax
movq %rsi, (%rax)
incq 0x200(%rdi)
popq %rax
retq
leaq 0x236d(%rip), %rdi      # 0x76e7
leaq 0x23ad(%rip), %rsi      # 0x772e
leaq 0x23bd(%rip), %rcx      # 0x7745
movl $0x85, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommytrieinp.c
// Function: tommy_trie_inplace_remove
void* tommy_trie_inplace_remove(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* ret;
	tommy_trie_inplace_node** let_ptr;

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

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	ret = trie_inplace_bucket_remove(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, 0, key);

	if (!ret)
		return 0;

	--trie_inplace->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x53d5
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x1a, %rax
leaq (%rdi,%rax,8), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x53f4
testq %rax, %rax
je 0x53ca
decq 0x200(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x230b(%rip), %rdi      # 0x76e7
leaq 0x234b(%rip), %rsi      # 0x772e
leaq 0x23c0(%rip), %rcx      # 0x77aa
movl $0xe0, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommytrieinp.c
// Function: tommy_trie_inplace_remove_existing
void* tommy_trie_inplace_remove_existing(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node)
{
	tommy_trie_inplace_node* ret;
	tommy_key_t key = node->key;
	tommy_trie_inplace_node** let_ptr;

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

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	ret = trie_inplace_bucket_remove(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

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

	--trie_inplace->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rsi), %rdx
movq %rdx, %rax
shrq $0x20, %rax
jne 0x5517
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x1a, %rax
leaq (%rdi,%rax,8), %rdi
callq 0x53f4
cmpq %r14, %rax
jne 0x5536
decq 0x200(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x21c9(%rip), %rdi      # 0x76e7
leaq 0x2209(%rip), %rsi      # 0x772e
leaq 0x22c1(%rip), %rcx      # 0x77ed
movl $0xf5, %edx
callq 0x1090
leaq 0x2160(%rip), %rdi      # 0x769d
leaq 0x21ea(%rip), %rsi      # 0x772e
leaq 0x22a2(%rip), %rcx      # 0x77ed
movl $0xfc, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommytrieinp.c
// Function: tommy_trie_inplace_bucket
tommy_trie_inplace_node* tommy_trie_inplace_bucket(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* node;
	tommy_uint_t shift;

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

	node = trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];
	shift = TOMMY_TRIE_INPLACE_BUCKET_SHIFT;

	while (node && node->key != key) {
		node = node->map[(key >> shift) & TOMMY_TRIE_INPLACE_TREE_MASK];
		shift -= TOMMY_TRIE_INPLACE_TREE_BIT;
	}

	return node;
}

// Assembly:
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x5594
movq %rsi, %rax
shrq $0x1a, %rax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x5590
movl $0x1a, %ecx
cmpq %rsi, 0x38(%rax)
je 0x5592
movq %rsi, %rdx
shrq %cl, %rdx
andl $0x3, %edx
addl $-0x2, %ecx
movq 0x18(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x5574
xorl %eax, %eax
popq %rcx
retq
leaq 0x214c(%rip), %rdi      # 0x76e7
leaq 0x218c(%rip), %rsi      # 0x772e
leaq 0x229e(%rip), %rcx      # 0x7847
movl $0x109, %edx            # imm = 0x109
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/amadvance[P]tommyds/tommyds/tommyhashtbl.c
// Function: tommy_hashtable_init
void tommy_hashtable_init(tommy_hashtable* hashtable, tommy_size_t bucket_max)
{
	if (bucket_max < 16)
		bucket_max = 16;
	else
		bucket_max = tommy_roundup_pow2(bucket_max);

	hashtable->bucket_max = bucket_max;
	hashtable->bucket_mask = hashtable->bucket_max - 1;

	/* initialize the vector using malloc()+memset() instead of calloc() */
	/* to ensure that all the memory in really allocated immediately */
	/* by the OS, and not deferred at later time. */
	/* this improves performance, because we start with a fully initialized hashtable. */
	hashtable->bucket = tommy_cast(tommy_hashtable_node**, tommy_malloc(hashtable->bucket_max * sizeof(tommy_hashtable_node*)));
	memset(hashtable->bucket, 0, hashtable->bucket_max * sizeof(tommy_hashtable_node*));

	hashtable->count = 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl $0x10, %esi
cmpq $0x10, %rax
jb 0x5612
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
movq %rcx, %rsi
shrq $0x20, %rsi
orq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
leaq -0x1(%rsi), %rax
movq %rax, 0x10(%rbx)
shlq $0x3, %rsi
movl $0x1, %edi
callq 0x10b0
movq %rax, (%rbx)
movq $0x0, 0x18(%rbx)
popq %rbx
retq