LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/node.cpp
// Function: Node::Node(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Node::Node(int key, string value, int level){
    key_value_pair = KeyValuePair(key, value);
    next.resize(level + 1);
    for (size_t i = 0; i < next.size(); i++){
        next[i] = NULL;
    }
    top_level = level;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %r15d
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
callq 0x445c
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
andw $0x0, 0x68(%rbx)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2270
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %ebp, %esi
callq 0x446e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x4718
leaq 0x28(%rsp), %rdi
callq 0x44c6
leaq 0x8(%rsp), %rdi
callq 0x20d0
leal 0x1(%r15), %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0x4732
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x468e
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x4670
movl %r15d, 0x6c(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46bf
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x44c6
jmp 0x46b3
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x46c2
movq %rax, %r15
movq %r14, %rdi
callq 0x4778
movq %rbx, %rdi
callq 0x44c6
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/skip_list.cpp
// Function: SkipList::SkipList(int, float)
SkipList::SkipList(int max_elements, float prob){
    max_level = (int) round(log(max_elements) / log(1/prob)) - 1;
    head = new Node(INT_MINI, max_level);
    tail = new Node(INT_MAXI, max_level);

    for (size_t i = 0; i < head->next.size(); i++) {
        head->next[i] = tail;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
movl %esi, %edi
callq 0x5675
movsd %xmm0, 0x8(%rsp)
movss 0x1d8e(%rip), %xmm0     # 0x671c
divss 0x4(%rsp), %xmm0
callq 0x2330
cvtss2sd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x20b0
cvttsd2si %xmm0, %ebp
decl %ebp
movl %ebp, 0x593c(%rip)      # 0xa2f4
pushq $0x70
popq %rdi
callq 0x21f0
movq %rax, %r14
movq %rax, %rdi
movl $0x80000000, %esi       # imm = 0x80000000
movl %ebp, %edx
callq 0x44f4
movq %r14, (%rbx)
pushq $0x70
popq %rdi
callq 0x21f0
movq %rax, %r14
movl 0x590e(%rip), %edx      # 0xa2f4
movq %rax, %rdi
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
callq 0x44f4
movq %r14, 0x8(%rbx)
xorl %eax, %eax
movq (%rbx), %rdx
movq 0x28(%rdx), %rcx
movq 0x30(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x4a19
movq %r14, (%rcx,%rax,8)
incq %rax
jmp 0x49f9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4a24
movq %rax, %rbx
pushq $0x70
popq %rsi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/skip_list.cpp
// Function: SkipList::find(int, std::vector<Node*, std::allocator<Node*>>&, std::vector<Node*, std::allocator<Node*>>&)
int SkipList::find(int key, vector<Node*> &predecessors, vector<Node*> &successors) {
    int found = -1;
    Node *prev = head; 

    for (int level = max_level; level >= 0; level--){
        Node *curr = prev->next[level];

        while (key > curr->get_key()){
            prev = curr;
            curr = prev->next[level];
        }
        
        if(found == -1 && key == curr->get_key()){
            found = level;
        }

        predecessors[level] = prev;
        successors[level] = curr;
    }
    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
movq (%rdi), %r13
pushq $-0x1
popq %r15
movl 0x5893(%rip), %ebx      # 0xa2f4
testl %ebx, %ebx
js 0x4ab7
movl %ebx, %r14d
movq %r13, %r12
movq %r12, %r13
movq 0x28(%r12), %rax
movq (%rax,%r14,8), %r12
movq %r12, %rdi
callq 0x46da
cmpl %ebp, %eax
jl 0x4a6b
cmpl $-0x1, %r15d
jne 0x4a9b
movq %r12, %rdi
callq 0x46da
cmpl %ebp, %eax
pushq $-0x1
popq %r15
cmovel %ebx, %r15d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %r13, (%rax,%r14,8)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %r12, (%rax,%r14,8)
decl %ebx
jmp 0x4a61
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/skip_list.cpp
// Function: SkipList::search[abi:cxx11](int)
string SkipList::search(int key){

    // Finds the predecessor and successors 
    vector<Node*> preds(max_level + 1); 
    vector<Node*> succs(max_level + 1);

    for (size_t i = 0; i < preds.size(); i++){
        preds[i] = NULL;
        succs[i] = NULL;
    }

    int found = find(key, preds, succs);

    // If not found return empty.
    if(found == -1){
        return "";
    }

    Node *curr = head; 

    for (int level = max_level; level >= 0; level--){
        while (curr->next[level] != NULL && key > curr->next[level]->get_key()){
            curr = curr->next[level];
        }
    }

    curr = curr->next[0];
    
    // If found, unmarked and fully linked, then return value. Else return empty.
    if ((curr != NULL) && (curr->get_key() == key) && succs[found]->fully_linked && !succs[found]->marked){
        return curr->get_value();
    }else {
        return "";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x5423(%rip), %rsi      # 0xa2f4
incq %rsi
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x567e
movslq 0x540a(%rip), %rsi      # 0xa2f4
incq %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x567e
xorl %eax, %eax
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x4f28
andq $0x0, (%rcx,%rax,8)
movq 0x8(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x4efe
leaq 0x20(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x4a3a
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x4fd1
movq (%r15), %r15
movl 0x53a2(%rip), %r12d     # 0xa2f4
testl %r12d, %r12d
js 0x4f7f
movl %r12d, %r13d
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4f7a
callq 0x46da
cmpl %ebp, %eax
jge 0x4f7a
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %r15
jmp 0x4f5a
decl %r12d
jmp 0x4f52
movq 0x28(%r15), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x4fbb
movq %r15, %rdi
callq 0x46da
cmpl %ebp, %eax
jne 0x4fbb
movslq %r14d, %rax
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rcx
movb 0x69(%rcx), %cl
testb $0x1, %cl
je 0x4fbb
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movb 0x68(%rax), %al
testb $0x1, %al
je 0x500b
leaq 0x1093(%rip), %rsi      # 0x6055
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ab6
jmp 0x4fe5
leaq 0x107d(%rip), %rsi      # 0x6055
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ab6
leaq 0x8(%rsp), %rdi
callq 0x4778
leaq 0x20(%rsp), %rdi
callq 0x4778
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x46e0
jmp 0x4fe5
jmp 0x5025
jmp 0x5025
jmp 0x5025
jmp 0x5025
movq %rax, %rbx
jmp 0x5032
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4778
leaq 0x20(%rsp), %rdi
callq 0x4778
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/skip_list.cpp
// Function: SkipList::display()
void SkipList::display(){
    for (int i = 0; i <= max_level; i++) {
        Node *temp = head;
        int count = 0;
        if(!(temp->get_key() == INT_MINI && temp->next[i]->get_key() == INT_MAXI)){
            printf("Level %d  ", i);
            while (temp != NULL){
                printf("%d -> ", temp->get_key());
                temp = temp->next[i];
                count++;
            }
            cout<<endl;
        }
        if(count == 3) break;
    }
    printf("---------- Display done! ----------\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x49f7(%rip), %r15      # 0x9fc8
leaq 0x1157(%rip), %r12      # 0x672f
xorl %r13d, %r13d
movslq 0x4d12(%rip), %rax      # 0xa2f4
cmpq %rax, %r13
jg 0x5657
movq (%rbx), %rbp
movq %rbp, %rdi
callq 0x46da
negl %eax
jno 0x560a
movq 0x28(%rbp), %rax
movq (%rax,%r13,8), %rdi
callq 0x46da
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x5652
leaq 0x1113(%rip), %rdi      # 0x6724
movl %r13d, %esi
xorl %eax, %eax
callq 0x2040
pushq $0x3
popq %r14
testq %rbp, %rbp
je 0x5645
movq %rbp, %rdi
callq 0x46da
movq %r12, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x2040
movq 0x28(%rbp), %rax
movq (%rax,%r13,8), %rbp
decl %r14d
jmp 0x561f
movq %r15, %rdi
callq 0x20f0
testl %r14d, %r14d
je 0x5657
incq %r13
jmp 0x55db
leaq 0x1109(%rip), %rdi      # 0x6767
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::Simulator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, int const&, int const&, int const&, int const&)
Simulator::Simulator(const std::string& replacementAlgorithm, const int& frames, const int& frameSize,
		const int& quantum, const int& workingSetSize, const int& maxReferences) : invertedPageTable(frames) {
	this->replacementAlgorithm = replacementAlgorithm;
	this->frames = frames;
	this->frameSize = frameSize;
	this->quantum = quantum;
	this->workingSetSize = workingSetSize;
	this->maxReferences = maxReferences;
	if (! replacementAlgorithm.compare("lru")) {
		lru = new LRU();
	}
	else if (! replacementAlgorithm.compare("ws")) {
		workingSetManager = new WorkingSetManager(workingSetSize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x30(%rbp)
movq %r8, %r13
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
addq $0x38, %rdi
movq %rdi, -0x38(%rbp)
movq %rdx, %rsi
callq 0x3678
andq $0x0, 0x58(%rbx)
andl $0x0, 0x60(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2100
movq 0x10(%rbp), %rax
movl (%r15), %ecx
movl %ecx, 0x20(%rbx)
movl (%r14), %ecx
movl %ecx, 0x24(%rbx)
movl (%r13), %ecx
movl %ecx, 0x28(%rbx)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x2c(%rbx)
movl (%rax), %eax
movl %eax, 0x30(%rbx)
leaq 0x2800(%rip), %rsi      # 0x503c
movq %r12, %rdi
callq 0x2090
testl %eax, %eax
je 0x2876
leaq 0x281c(%rip), %rsi      # 0x506b
movq %r12, %rdi
callq 0x2090
testl %eax, %eax
jne 0x2894
pushq $0x8
popq %rdi
callq 0x2190
movq %rax, %r12
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x3a94
pushq $0x50
jmp 0x288f
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r12
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x48
popq %rax
movq %r12, (%rbx,%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x2170
jmp 0x28b8
movq %rax, %r14
jmp 0x28c1
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x36c8
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::~Simulator()
Simulator::~Simulator() {
	if (! replacementAlgorithm.compare("lru")) {
		delete lru;
	}
	else if (! replacementAlgorithm.compare("ws")) {
		delete workingSetManager;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2759(%rip), %rsi      # 0x503c
callq 0x2090
testl %eax, %eax
je 0x2912
leaq 0x2778(%rip), %rsi      # 0x506b
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
jne 0x292b
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x2923
movq %r14, %rdi
callq 0x3afe
jmp 0x2923
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x2923
movq %r14, %rdi
callq 0x31d4
movq %r14, %rdi
callq 0x2170
leaq 0x38(%rbx), %rdi
callq 0x36c8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::run()
void Simulator::run() {
	ifstream trace1;
	ifstream trace2;
	trace1.open("bzip.trace", ios::in);
	trace2.open("gcc.trace", ios::in);

	bool processSwitch = false;

	/* Receive page requests */
	Address *address;
	while ((address = this->getTrace(trace1, trace2, processSwitch)) != NULL) {
		statistics.pageRequests++;
		//invertedPageTable.print();
		//cout << "Trace: " << address->toString() << endl;
		address->print();
		if (! replacementAlgorithm.compare("lru")) {
			this->runLRU(address);
		}
		else if (! replacementAlgorithm.compare("ws")) {
			this->runWorkingSet(address, processSwitch);
		}
	}
	cout << "\nFrames: " << frames << statistics.toString() << endl;
	trace1.close();
	trace2.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rdi, %rbx
leaq -0x460(%rbp), %rdi
callq 0x21a0
leaq -0x258(%rbp), %rdi
callq 0x21a0
leaq 0x277d(%rip), %rsi      # 0x50f3
leaq -0x460(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2110
leaq 0x2772(%rip), %rsi      # 0x50fe
leaq -0x258(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2110
leaq -0x29(%rbp), %r15
movb $0x0, (%r15)
leaq 0x58(%rbx), %r14
leaq -0x258(%rbp), %r13
movq %rbx, %rdi
leaq -0x460(%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2ae2
movq %rax, %r12
testq %rax, %rax
je 0x2a19
incl (%r14)
movq %r12, %rdi
callq 0x345a
movq %rbx, %rdi
leaq 0x265c(%rip), %rsi      # 0x503c
callq 0x2090
testl %eax, %eax
je 0x2a0c
movq %rbx, %rdi
leaq 0x2678(%rip), %rsi      # 0x506b
callq 0x2090
testl %eax, %eax
jne 0x29ae
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2dfa
jmp 0x29ae
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2cea
jmp 0x29ae
movq 0x55b8(%rip), %rdi      # 0x7fd8
leaq 0x26e1(%rip), %rsi      # 0x5108
callq 0x2180
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x2240
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x3f78
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x460(%rbp), %rdi
callq 0x2060
leaq -0x258(%rbp), %rdi
callq 0x2060
leaq -0x258(%rbp), %rdi
callq 0x2080
leaq -0x460(%rbp), %rdi
callq 0x2080
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2abe
movq %rax, %rbx
jmp 0x2acd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
jmp 0x2ac1
jmp 0x2abe
jmp 0x2abe
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x2080
leaq -0x460(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::runLRU(Address*)
void Simulator::runLRU(Address *address) {
	//lru->print();
	Address **mappingFrame = invertedPageTable.getFrameByAddress(*address);
	if (mappingFrame != NULL) {
		/* Page already in memory */
		lru->prioritize(*mappingFrame);
		this->checkWrite(address, *mappingFrame);
		delete address;
	}
	else {
		/* Page not in memory */
		statistics.pageFaults++;
		Address **freeFrame = invertedPageTable.getFreeFrame();
		if (freeFrame != NULL) {
			invertedPageTable.occupyFrame(freeFrame, address);
			lru->getRecentList().push_front(address);
			printPageFault(NULL, address);
		}
		else {
			Address *victim;
			victim = lru->getVictim();
			Address **victimFrame = invertedPageTable.getFrameByAddress(*victim);
			invertedPageTable.occupyFrame(victimFrame, address);
			lru->getRecentList().push_front(address);
			printPageFault(victim, address);
			if (victim->getDirty()) {
				cout << " Saving victim to disk.";
				statistics.diskWrites++;
			}
			delete victim;
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
leaq 0x38(%rdi), %r12
movq %r12, %rdi
callq 0x3708
testq %rax, %rax
je 0x2d42
movq %rax, %r15
movq 0x48(%rbx), %rdi
movq (%rax), %rsi
callq 0x38e8
movq (%r15), %rdx
movq %r14, %rsi
callq 0x2f9a
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2170
incl 0x5c(%rbx)
movq %r12, %rdi
callq 0x3766
testq %rax, %rax
je 0x2d7c
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3796
movq 0x48(%rbx), %rdi
leaq -0x28(%rbp), %rbx
movq %rbx, %rsi
callq 0x31c4
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x3008
jmp 0x2de1
movq 0x48(%rbx), %rdi
callq 0x391a
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x3708
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3796
movq 0x48(%rbx), %rdi
leaq -0x28(%rbp), %r14
movq %r14, %rsi
callq 0x31c4
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3008
cmpb $0x1, 0x8(%r15)
jne 0x2dd9
movq 0x520e(%rip), %rdi      # 0x7fd8
leaq 0x2341(%rip), %rsi      # 0x5112
callq 0x2180
incl 0x60(%rbx)
movq %r15, %rdi
callq 0x2170
movq 0x51f0(%rip), %rdi      # 0x7fd8
callq 0x20e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::checkWrite(Address*, Address*)
void Simulator::checkWrite(Address *address, Address *mappingAddress) {
	if (address->getDirty() == true && mappingAddress->getDirty() == false) {
		mappingAddress->setDirty(true);
		cout << "Page " << address->getPageNumber() << " from process " << address->getProcessId()
		     << " changed to dirty" << endl;
	}
}

// Assembly:
cmpb $0x1, 0x8(%rsi)
jne 0x2fa6
cmpb $0x0, 0x8(%rdx)
je 0x2fa7
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x1, 0x8(%rdx)
movq 0x501d(%rip), %rdi      # 0x7fd8
leaq 0x21ab(%rip), %rsi      # 0x516d
callq 0x2180
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x219a(%rip), %rsi      # 0x5173
movq %rax, %rdi
callq 0x2180
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x2190(%rip), %rsi      # 0x5182
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::printPageFault(Address*, Address*)
void Simulator::printPageFault(Address *victim, Address *address) {
	cout << "Page fault on requesting page " << address->getPageNumber() << " from process "
			<< address->getProcessId() << ".";
	if (victim != NULL) {
		cout << " Memory full, replacing page " << victim->getPageNumber() << " from process "
				<< victim->getProcessId() << ".";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4fbc(%rip), %rdi      # 0x7fd8
leaq 0x2173(%rip), %rsi      # 0x5196
callq 0x2180
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x2138(%rip), %rsi      # 0x5173
movq %rax, %rdi
callq 0x2180
movl (%r14), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x21a4(%rip), %rsi      # 0x51f9
movq %rax, %rdi
callq 0x2180
testq %rbx, %rbx
je 0x30ac
movq 0x4f6f(%rip), %rdi      # 0x7fd8
leaq 0x2145(%rip), %rsi      # 0x51b5
callq 0x2180
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x20ec(%rip), %rsi      # 0x5173
movq %rax, %rdi
callq 0x2180
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x2159(%rip), %rsi      # 0x51f9
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2180
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::restoreWorkingSetMemory(std::__cxx11::list<Address, std::allocator<Address>>&, bool&)
void Simulator::restoreWorkingSetMemory(std::list<Address>& workingSet, bool& change) {
	for (list<Address>::iterator it = workingSet.begin() ; it != workingSet.end() ; it++) {
		Address **mappingFrame = invertedPageTable.getFrameByAddress(*it);
		if (mappingFrame == NULL) {
			statistics.pageFaults++;
			if (! change) {
				change = true;
			}
			Address **victimFrame = invertedPageTable.getVictimFrameNotInSet(workingSet);
			Address *toDelete = *victimFrame;
			*victimFrame = new Address(*it);
			cout << "\t";
			printPageFault(toDelete, &(*it));
			if (toDelete->getDirty()) {
				cout << " Saving victim to disk.";
				statistics.diskWrites++;
			}
			cout << endl;
			delete toDelete;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x38(%rdi), %rbx
movq 0x4eff(%rip), %r12      # 0x7fd8
movq %rsi, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
movq (%r14), %r14
cmpq -0x40(%rbp), %r14
je 0x3193
leaq 0x10(%r14), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3708
testq %rax, %rax
jne 0x30e1
movq -0x30(%rbp), %rax
incl 0x5c(%rax)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x3119
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x37a0
movq %rax, %r15
movq (%rax), %rbx
pushq $0xc
popq %rdi
callq 0x2190
movq (%r13), %rcx
movq %rcx, (%rax)
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%rax)
movq %rax, (%r15)
movq %r12, %rdi
leaq 0x2046(%rip), %rsi      # 0x5194
callq 0x2180
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3008
cmpb $0x1, 0x8(%rbx)
jne 0x317a
movq %r12, %rdi
leaq 0x1fa4(%rip), %rsi      # 0x5112
callq 0x2180
movq -0x30(%rbp), %rax
incl 0x60(%rax)
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
movq -0x48(%rbp), %rbx
jmp 0x30e1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::InvertedPageTable(int const&)
InvertedPageTable::InvertedPageTable(const int& frames) {
	invertedPageTableSize = frames;
	invertedPageTable = new Address *[frames];
	for (int frame = 0 ; frame < frames ; frame++) {
		invertedPageTable[frame] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %r14
leaq (,%r14,8), %rax
testq %r14, %r14
movl %r14d, 0x8(%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%rbx)
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %rax, %rcx
je 0x36c3
movq (%rbx), %rdx
andq $0x0, (%rdx,%rax,8)
incq %rax
jmp 0x36b1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::~InvertedPageTable()
InvertedPageTable::~InvertedPageTable() {
	for (int frame = 0 ; frame < invertedPageTableSize ; frame++ ) {
		if (invertedPageTable[frame] != NULL) {
			delete invertedPageTable[frame];
		}
	}
	delete[] invertedPageTable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r14
jge 0x36f4
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x36ef
callq 0x2170
incq %r14
jmp 0x36d5
testq %rdi, %rdi
je 0x3702
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::getFrameByAddress(Address const&)
Address **InvertedPageTable::getFrameByAddress(const Address& address) {
	for (int frame = 0 ; frame < invertedPageTableSize ; frame++ ) {
		if (invertedPageTable[frame] != NULL && invertedPageTable[frame]->equals(address)) {
			return &invertedPageTable[frame];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x3754
movq (%r14), %rax
movq (%rax,%r12), %rdi
testq %rdi, %rdi
je 0x3745
movq %r15, %rsi
callq 0x32e4
testb %al, %al
jne 0x374e
incq %r13
addq $0x8, %r12
jmp 0x3724
addq (%r14), %r12
movq %r12, %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_O2/iPapatsoris[P]Paging-Simulator/InvertedPageTable.cpp
// Function: InvertedPageTable::getFreeFrame()
Address **InvertedPageTable::getFreeFrame() {
	for (int frame = 0 ; frame < invertedPageTableSize ; frame++ ) {
		if (invertedPageTable[frame] == NULL) {
			return &invertedPageTable[frame];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %ecx
movq (%rdi), %rdx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
addq $-0x8, %rdx
subq $0x1, %rcx
jb 0x3791
leaq 0x8(%rdx), %rax
cmpq $0x0, 0x8(%rdx)
movq %rax, %rdx
jne 0x377b
jmp 0x3793
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r15
movq %rdi, %r14
pushq $-0x8
popq %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x37eb
movq (%r15), %rdi
movq (%r14), %rax
movq 0x8(%rax,%r12), %rdx
movq %r15, %rsi
callq 0x38ab
incq %r13
addq $0x8, %r12
cmpq %r15, %rax
jne 0x37bd
addq (%r14), %r12
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47bf(%rip), %r14      # 0x7fd8
leaq 0x1aa9(%rip), %rsi      # 0x52c9
movq %r14, %rdi
callq 0x2180
xorl %r13d, %r13d
leaq 0x1ab3(%rip), %r15      # 0x52e5
leaq -0x48(%rbp), %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jge 0x3888
movq (%rbx), %rax
movq (%rax,%r13,8), %rsi
testq %rsi, %rsi
je 0x3870
movq %r12, %rdi
callq 0x3310
movq %r14, %rdi
movq %r12, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20d0
jmp 0x3883
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
incq %r13
jmp 0x3836
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x30(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jne 0x3bcf
movq %rdx, %r15
pushq $0xc
popq %rdi
callq 0x2190
movq (%r14), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq %rax, (%r15)
movq %r14, %rdi
callq 0x3d44
movq (%r14), %rdi
movq (%r15), %rdx
movq %r14, %rsi
callq 0x3e31
cmpq %r14, %rax
je 0x3bc3
movq (%r15), %rdi
callq 0x2170
andq $0x0, (%r15)
jmp 0x3bcf
leaq 0x18(%r14), %rdi
movq (%r15), %rsi
callq 0x3d52
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3dda
movq 0x18(%r14), %rdi
addq $0x18, %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3e31
cmpq %r14, %rax
je 0x3bfd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3dda
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x4391(%rip), %r14      # 0x7fd8
leaq 0x169c(%rip), %rsi      # 0x52ea
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
leaq -0x40(%rbp), %r15
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x3c98
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3310
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x20d0
jmp 0x3c65
movq 0x4339(%rip), %r14      # 0x7fd8
leaq 0x165a(%rip), %rsi      # 0x5300
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
addq $0x18, %rbx
leaq -0x40(%rbp), %r15
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x3cf4
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3310
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x20d0
jmp 0x3cc1
movq 0x42dd(%rip), %rdi      # 0x7fd8
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d0f
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x42b8
movq %r15, %rdi
movq %r14, %rsi
callq 0x55ea
movq %rax, %r14
addq $0x8, %r15
cmpq %r15, %rax
je 0x326f
movq 0x30(%rbx), %rax
addq $0x40, %r14
cmpq 0x10(%rbx), %rax
je 0x3254
movq %r14, %rdi
callq 0x4394
testq %rax, %rax
je 0x32ba
movq %rax, %r14
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x4cca
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x31d4
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x4050
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2ff5(%rip), %rsi      # 0x6276
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x55d4
xorl %ebp, %ebp
leaq 0x78df(%rip), %rsi      # 0xab88
movq 0x7d18(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2250
jmp 0x3303
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2f9d(%rip), %rsi      # 0x6269
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x55d4
xorl %ebp, %ebp
leaq 0x7894(%rip), %rsi      # 0xab88
movq 0x7ccd(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2250
jmp 0x3307
jmp 0x331b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x331e
jmp 0x333c
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x333c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4050
jmp 0x333c
jmp 0x3339
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rdi
callq 0x5669
testq %rax, %rax
je 0x336c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2f0d(%rip), %rsi      # 0x628b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56bc
xorl %ebp, %ebp
leaq 0x784a(%rip), %rsi      # 0xabf0
movq 0x7c1b(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x33cc
jmp 0x33d4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42b8
movq %r14, %rdi
movq %r15, %rsi
callq 0x56e8
addq $0x8, %r14
cmpq %r14, %rax
je 0x34d4
movq 0x30(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
je 0x34d8
addq $0x40, %rax
movq %rax, %rdi
callq 0x4394
testq %rax, %rax
je 0x34d4
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4cca
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3460
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x4050
jmp 0x34da
xorl %ebx, %ebx
jmp 0x34da
movb $0x1, %bl
movq %rsp, %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4050
jmp 0x3502
jmp 0x34ff
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x42b8
movq %r15, %rdi
movq %r14, %rsi
callq 0x56e8
movq %rax, %r14
addq $0x8, %r15
cmpq %r15, %rax
je 0x35ad
movq 0x30(%rbx), %rax
addq $0x40, %r14
cmpq 0x10(%rbx), %rax
je 0x3592
movq %r14, %rdi
callq 0x4394
testq %rax, %rax
je 0x35f8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x4cca
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x3512
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x4050
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2cb7(%rip), %rsi      # 0x6276
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x55d4
xorl %ebp, %ebp
leaq 0x75a1(%rip), %rsi      # 0xab88
movq 0x79da(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2250
jmp 0x3641
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2c5f(%rip), %rsi      # 0x6269
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x55d4
xorl %ebp, %ebp
leaq 0x7556(%rip), %rsi      # 0xab88
movq 0x798f(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2250
jmp 0x3645
jmp 0x3659
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x365c
jmp 0x367a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x367a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4050
jmp 0x367a
jmp 0x3677
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rdi
callq 0x5669
testq %rax, %rax
je 0x36aa
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2bc9(%rip), %rsi      # 0x6285
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2fe0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56bc
xorl %ebp, %ebp
leaq 0x750c(%rip), %rsi      # 0xabf0
movq 0x78dd(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x370a
jmp 0x3712
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
cmpq %rsi, 0x30(%r14)
je 0x42de
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x4420
jmp 0x42ee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x51a6
xorl %ebp, %ebp
leaq 0x1053(%rip), %r15      # 0x6237
leaq 0x8(%rsp), %r12
cmpq 0x8(%r14), %rbp
jae 0x5239
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2290
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x520a
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 0x5288
movq %r12, %rdi
callq 0x20a0
incq %r13
movq %r13, %rbp
jmp 0x51e9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x525a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4050
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movl %edi, %ebp
leaq 0x2e43(%rip), %rsi      # 0x4148
movq %rsp, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x1752
movq %r14, %rdi
callq 0x1150
movq %rax, %r15
movq %rsp, %rdi
callq 0x17be
movq 0x2e1b(%rip), %rdi      # 0x4148
leaq 0xcd0(%rip), %rsi       # 0x2004
callq 0x1110
testq %rax, %rax
je 0x13a4
movq %rax, %r14
callq 0x1060
cltq
movslq %ebp, %r12
subq %r12, %r15
cqto
idivq %r15
xorl %r15d, %r15d
movq %r14, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x1100
movslq %ebx, %rax
testl %r12d, %r12d
cmovlel %r15d, %r12d
imulq $0x64, %rax, %rbx
leaq 0x2de8(%rip), %r13      # 0x4160
cmpq %r15, %r12
je 0x1393
movq %r14, %rdi
callq 0x1190
leaq (%rbx,%r15), %rcx
movb %al, (%r13,%rcx)
incq %r15
jmp 0x1378
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
pushq $0x2
popq %rdi
callq 0x1120
movq %rax, %rbx
movq %rsp, %rdi
callq 0x17be
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0xc95(%rip), %rdi       # 0x2071
callq 0x1180
leaq 0xcaa(%rip), %rdi       # 0x2092
callq 0x1180
leaq 0xcc7(%rip), %rdi       # 0x20bb
callq 0x1180
leaq 0xcd9(%rip), %rdi       # 0x20d9
callq 0x1180
leaq 0xd02(%rip), %rdi       # 0x210e
callq 0x1180
leaq 0xd24(%rip), %rdi       # 0x213c
callq 0x1180
leaq 0xd4e(%rip), %rdi       # 0x2172
callq 0x1180
leaq 0xd77(%rip), %rdi       # 0x21a7
callq 0x1180
leaq 0xda4(%rip), %rdi       # 0x21e0
callq 0x1180
leaq 0xdd0(%rip), %rdi       # 0x2218
callq 0x1180
leaq 0xdfb(%rip), %rdi       # 0x224f
callq 0x1180
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x1160
movl %ebx, %edi
callq 0x1160
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq 0xdc8(%rip), %rsi       # 0x2004
leaq -0x40(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1040
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1352
leaq -0x40(%rbp), %rdi
callq 0x1060
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13ba
movq 0x2d65(%rip), %rdi      # 0x3fd8
leaq 0xd91(%rip), %rsi       # 0x200b
callq 0x1090
movq %rax, %rdi
callq 0x1070
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13ba
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1426
leaq -0x50(%rbp), %rdi
callq 0x1470
movq 0x2d27(%rip), %rdi      # 0x3fd8
leaq 0xd53(%rip), %rsi       # 0x200b
callq 0x1090
movq %rax, %rdi
callq 0x1070
leaq -0x60(%rbp), %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1498
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x1426
leaq -0x60(%rbp), %rdi
callq 0x1470
leaq -0x40(%rbp), %rdi
callq 0x1470
leaq -0x20(%rbp), %rdi
callq 0x1470
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x1315
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1470
jmp 0x1337
movq %rax, %rbx
jmp 0x1340
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1060
jmp 0x1349
movq %rax, %rbx
jmp 0x1349
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1470
leaq -0x20(%rbp), %rdi
callq 0x1470
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: start
void start(const char* str)
{
	cache_clear();
	compare_counter = 0;
	the_str = str;
	the_start = nano();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1262
andl $0x0, 0x9b63(%rip)      # 0xadf0
movq %rbx, 0x1009b6c(%rip)   # 0x100ae00
callq 0x12a2
movq %rax, 0x1009b68(%rip)   # 0x100ae08
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/./tommyds/tommyhash.h
// Function: tommy_inthash_u32
tommy_inline tommy_uint32_t tommy_inthash_u32(tommy_uint32_t key)
{
	key -= key << 6;
	key ^= key >> 17;
	key -= key << 9;
	key ^= key << 4;
	key -= key << 3;
	key ^= key << 10;
	key ^= key >> 15;

	return key;
}

// Assembly:
imull $-0x3f, %edi, %eax
movl %eax, %ecx
shrl $0x11, %ecx
xorl %eax, %ecx
imull $0xfffffe01, %ecx, %eax # imm = 0xFFFFFE01
imull $0xffffe010, %ecx, %ecx # imm = 0xFFFFE010
xorl %eax, %ecx
imull $-0x7, %ecx, %eax
imull $0xffffe400, %ecx, %ecx # imm = 0xFFFFE400
xorl %eax, %ecx
movl %ecx, %eax
shrl $0xf, %eax
xorl %ecx, %eax
retq