LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x99e0
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa050
movq -0xa0(%rbp), %rdi
addq $0x40, %rdi
callq 0xa070
movq -0xa0(%rbp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
movl %esi, -0x94(%rbp)
callq 0xa090
movq -0xa0(%rbp), %rdi
movl -0x94(%rbp), %esi
addq $0x69, %rdi
callq 0xa090
movq -0x90(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x9dda
movl -0x84(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x9a00
jmp 0x9def
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa0c0
jmp 0x9e01
leaq -0x48(%rbp), %rdi
callq 0x9ab0
leaq -0x68(%rbp), %rdi
callq 0x3170
movq -0xb0(%rbp), %rdi
addq $0x28, %rdi
movl -0x1c(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0xa100
jmp 0x9e2d
movq $0x0, -0x80(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0xb8(%rbp)
addq $0x28, %rdi
callq 0xa190
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0x9ec4
movq -0xb0(%rbp), %rdi
addq $0x28, %rdi
movq -0x80(%rbp), %rsi
callq 0xa1b0
movq $0x0, (%rax)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x9e35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x9eda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x9eb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9ab0
leaq -0x68(%rbp), %rdi
callq 0x3170
jmp 0x9eda
movq -0xb0(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x6c(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0xa1d0
movq -0xa0(%rbp), %rdi
callq 0x9ab0
movq -0x70(%rbp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %edi
callq 0xca40
movsd %xmm0, -0x40(%rbp)
movss -0x10(%rbp), %xmm1
movss 0x4986(%rip), %xmm0     # 0xf7dc
divss %xmm1, %xmm0
callq 0xca60
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x30e0
cvttsd2si %xmm0, %eax
decl %eax
movl %eax, 0xc4e4(%rip)      # 0x17364
movl $0x70, %edi
callq 0x3250
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
callq 0xca80
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl 0xc4c1(%rip), %edx      # 0x17364
callq 0x9b30
jmp 0xaeaa
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl $0x70, %edi
callq 0x3250
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
callq 0xca90
movq -0x50(%rbp), %rdi
movl %eax, %esi
movl 0xc48c(%rip), %edx      # 0x17364
callq 0x9b30
jmp 0xaedf
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq (%rax), %rdi
addq $0x28, %rdi
callq 0xa190
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0xaf80
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0xa1b0
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xaef3
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x70, %esi
callq 0x3260
jmp 0xaf86
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x70, %esi
callq 0x3260
jmp 0xaf86
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33b0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl 0xc3a5(%rip), %eax      # 0x17364
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xb088
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x34(%rbp), %rsi
callq 0xa1b0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9f00
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jle 0xb01e
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x34(%rbp), %rsi
callq 0xa1b0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xafe4
cmpl $-0x1, -0x24(%rbp)
jne 0xb042
movl -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9f00
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jne 0xb042
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xa1b0
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xa1b0
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xafc2
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/skip_list.cpp
// Function: SkipList::get_random_level()
int SkipList::get_random_level() {
    int l = 0;
    while(static_cast <float> (rand()) / static_cast <float> (RAND_MAX) <= 0.5){
        l++;
    }
    return l > max_level ? max_level : l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x3080
cvtsi2ss %eax, %xmm0
movss 0x471c(%rip), %xmm1     # 0xf7e0
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4714(%rip), %xmm0     # 0xf7e8
ucomisd %xmm1, %xmm0
jb 0xb0e5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb0b3
movl -0xc(%rbp), %eax
cmpl 0xc276(%rip), %eax      # 0x17364
jle 0xb0fb
movl 0xc26e(%rip), %eax      # 0x17364
movl %eax, -0x10(%rbp)
jmp 0xb101
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xaa40(%rip), %eax      # 0x17364
jg 0xc9ff
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f00
movl %eax, -0x2c(%rbp)
callq 0xca80
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0xc980
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa1b0
movq (%rax), %rdi
callq 0x9f00
movl %eax, -0x30(%rbp)
callq 0xca90
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
je 0xc9e7
movl -0xc(%rbp), %esi
leaq 0x2e66(%rip), %rdi      # 0xf7f0
movb $0x0, %al
callq 0x3050
cmpq $0x0, -0x18(%rbp)
je 0xc9d4
movq -0x18(%rbp), %rdi
callq 0x9f00
movl %eax, %esi
leaq 0x2e51(%rip), %rdi      # 0xf7fb
movb $0x0, %al
callq 0x3050
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa1b0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc991
movq 0xa5ed(%rip), %rdi      # 0x16fc8
movq 0xa5c6(%rip), %rsi      # 0x16fa8
callq 0x3280
cmpl $0x3, -0x1c(%rbp)
jne 0xc9ef
jmp 0xc9ff
jmp 0xc9f1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc91b
leaq 0x2dfc(%rip), %rdi      # 0xf802
movb $0x0, %al
callq 0x3050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x2270
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4a30
jmp 0x2a5f
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3a10
jmp 0x2a72
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
jmp 0x2a81
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
leaq 0x5582(%rip), %rsi      # 0x803f
callq 0x20c0
cmpl $0x0, %eax
jne 0x2b3a
movl $0x18, %edi
callq 0x21f0
movq %rax, -0x68(%rbp)
jmp 0x2ad7
movq -0x68(%rbp), %rdi
callq 0x3a40
jmp 0x2ae2
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x48(%rax)
jmp 0x2b95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2bad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2ba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b9b
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21d0
jmp 0x2b9b
movq -0x10(%rbp), %rdi
leaq 0x5529(%rip), %rsi      # 0x806e
callq 0x20c0
cmpl $0x0, %eax
jne 0x2b93
movl $0x8, %edi
callq 0x21f0
movq %rax, -0x70(%rbp)
jmp 0x2b5f
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5b80
jmp 0x2b6e
movq -0x58(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x50(%rax)
jmp 0x2b93
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21d0
jmp 0x2b9b
jmp 0x2b95
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3a60
movq -0x48(%rbp), %rdi
callq 0x4ac0
movq -0x50(%rbp), %rdi
callq 0x2140
movq -0x38(%rbp), %rdi
callq 0x2300
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x5464(%rip), %rsi      # 0x803f
callq 0x20c0
cmpl $0x0, %eax
jne 0x2c0b
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2c09
movq -0x18(%rbp), %rdi
callq 0x3a70
movq -0x18(%rbp), %rdi
callq 0x21d0
jmp 0x2c48
movq -0x10(%rbp), %rdi
leaq 0x5458(%rip), %rsi      # 0x806e
callq 0x20c0
cmpl $0x0, %eax
jne 0x2c46
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2c44
movq -0x20(%rbp), %rdi
callq 0x5c20
movq -0x20(%rbp), %rdi
callq 0x21d0
jmp 0x2c46
jmp 0x2c48
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x3a60
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x4ac0
movq -0x10(%rbp), %rdi
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x326d
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x51a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x3650
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3268
movq -0x40(%rbp), %rdi
callq 0x3a90
movq -0x40(%rbp), %rdi
callq 0x21d0
jmp 0x3393
movq -0x38(%rbp), %rdi
movl 0x5c(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rdi)
addq $0x38, %rdi
callq 0x4c00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x32ce
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4c70
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3aa0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3ab0
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3720
jmp 0x3380
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x51e0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
movq -0x28(%rbp), %rsi
callq 0x4b60
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4c70
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3aa0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3ab0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3720
movq -0x28(%rbp), %rdi
callq 0x3af0
testb $0x1, %al
jne 0x333e
jmp 0x335e
movq 0x8c93(%rip), %rdi      # 0xbfd8
leaq 0x4dd5(%rip), %rsi      # 0x8121
callq 0x21e0
movq -0x38(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x337e
movq -0x48(%rbp), %rdi
callq 0x3a90
movq -0x48(%rbp), %rdi
callq 0x21d0
jmp 0x3380
movq 0x8c51(%rip), %rdi      # 0xbfd8
movq 0x8c3a(%rip), %rsi      # 0xbfc8
callq 0x2200
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3af0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3713
movq -0x18(%rbp), %rdi
callq 0x3af0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3713
movq -0x18(%rbp), %rdi
movb $0x1, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x3b20
movq 0x892e(%rip), %rdi      # 0xbfd8
leaq 0x4acb(%rip), %rsi      # 0x817c
callq 0x21e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b40
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x4aaa(%rip), %rsi      # 0x8182
callq 0x21e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b10
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x4a92(%rip), %rsi      # 0x8191
callq 0x21e0
movq %rax, %rdi
movq 0x88ba(%rip), %rsi      # 0xbfc8
callq 0x2200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x88a1(%rip), %rdi      # 0xbfd8
leaq 0x4a67(%rip), %rsi      # 0x81a5
callq 0x21e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b40
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x4a1d(%rip), %rsi      # 0x8182
callq 0x21e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b10
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x4a7c(%rip), %rsi      # 0x8208
callq 0x21e0
cmpq $0x0, -0x8(%rbp)
je 0x37f9
movq 0x8839(%rip), %rdi      # 0xbfd8
leaq 0x4a1e(%rip), %rsi      # 0x81c4
callq 0x21e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b40
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x49b5(%rip), %rsi      # 0x8182
callq 0x21e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b10
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x4a14(%rip), %rsi      # 0x8208
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b90
testb $0x1, %al
jne 0x384c
jmp 0x3991
movq -0x50(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bf0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x4b60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x397b
movq -0x50(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x3899
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x4c90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0xc, %edi
callq 0x21f0
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bf0
movq -0x68(%rbp), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq 0x86ea(%rip), %rdi      # 0xbfd8
leaq 0x48ae(%rip), %rsi      # 0x81a3
callq 0x21e0
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bf0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x3720
movq -0x40(%rbp), %rdi
callq 0x3af0
testb $0x1, %al
jne 0x3926
jmp 0x3946
movq 0x86ab(%rip), %rdi      # 0xbfd8
leaq 0x47ed(%rip), %rsi      # 0x8121
callq 0x21e0
movq -0x50(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq 0x868b(%rip), %rdi      # 0xbfd8
movq 0x8674(%rip), %rsi      # 0xbfc8
callq 0x2200
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x3979
movq -0x70(%rbp), %rdi
callq 0x3a90
movq -0x70(%rbp), %rdi
callq 0x21d0
jmp 0x397b
jmp 0x397d
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3c20
movq %rax, -0x48(%rbp)
jmp 0x3829
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::toggleProcessId(int&)
void Simulator::toggleProcessId(int& processId) {
	if (processId == 1) {
		processId = 2;
	}
	else {
		processId = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x39bd
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x39c7
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
popq %rbp
retq
nopl (%rax)
// File: iPapatsoris[P]Paging-Simulator/Simulator.cpp
// Function: Simulator::toggleTrace(std::istream**, std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ifstream<char, std::char_traits<char>>&)
void Simulator::toggleTrace(istream **trace, ifstream& trace1, ifstream& trace2) {
	if (*trace == &trace1) {
		*trace = &trace2;
	}
	else {
		*trace = &trace1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x39fa
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3a05
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4ab3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a8a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4b33
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4b26
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4b24
movq -0x20(%rbp), %rdi
callq 0x3a90
movq -0x20(%rbp), %rdi
callq 0x21d0
jmp 0x4b26
jmp 0x4b28
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4adb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b4d
movq -0x28(%rbp), %rdi
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4be0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4bd3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x4370
testb $0x1, %al
jne 0x4bbb
jmp 0x4bd3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4be8
jmp 0x4bd5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b7f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4c5a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4c4d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4c62
jmp 0x4c4f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c17
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4d44
movq -0x18(%rbp), %rdi
callq 0x4ee0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4f10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4e90
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4f10
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4e60
testb $0x1, %al
jne 0x4d1c
jmp 0x4d34
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4d4c
jmp 0x4d36
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4caf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x725d(%rip), %rdi      # 0xbfd8
leaq 0x3557(%rip), %rsi      # 0x82d9
callq 0x21e0
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4e4a
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4dd4
movq 0x7221(%rip), %rdi      # 0xbfd8
leaq 0x3537(%rip), %rsi      # 0x82f5
callq 0x21e0
movq %rax, %rdi
movq 0x71fb(%rip), %rsi      # 0xbfc8
callq 0x2200
jmp 0x4e3a
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x43e0
movq -0x58(%rbp), %rsi
movq 0x71dd(%rip), %rdi      # 0xbfd8
callq 0x21b0
movq %rax, -0x50(%rbp)
jmp 0x4e06
movq -0x50(%rbp), %rdi
movq 0x71b7(%rip), %rsi      # 0xbfc8
callq 0x2200
jmp 0x4e18
leaq -0x30(%rbp), %rdi
callq 0x2140
jmp 0x4e3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2140
jmp 0x4e50
jmp 0x4e3c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d8e
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5e50
testb $0x1, %al
jne 0x5cfa
jmp 0x5dc9
movl $0xc, %edi
callq 0x21f0
movq -0x60(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x6120
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rdi
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0x6150
movq -0x60(%rbp), %rdi
callq 0x3b60
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x3bc0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x61b0
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3bc0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6180
testb $0x1, %al
jne 0x5d83
jmp 0x5d99
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6200
jmp 0x5dc7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x5dbc
movq -0x70(%rbp), %rdi
callq 0x3a90
movq -0x70(%rbp), %rdi
callq 0x21d0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x5dc9
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6320
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x3b60
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x3bc0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x61b0
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x3bc0
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6180
testb $0x1, %al
jne 0x5e31
jmp 0x5e42
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x6320
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x6107(%rip), %rdi      # 0xbfd8
leaq 0x2422(%rip), %rsi      # 0x82fa
callq 0x21e0
movq %rax, %rdi
movq 0x60e1(%rip), %rsi      # 0xbfc8
callq 0x2200
movq -0x90(%rbp), %rdi
callq 0x4ee0
movq %rax, -0x10(%rbp)
movq -0x90(%rbp), %rdi
callq 0x4f10
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5070
testb $0x1, %al
jne 0x5f22
jmp 0x5fa6
leaq -0x10(%rbp), %rdi
callq 0x5100
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x43e0
movq -0xa0(%rbp), %rsi
movq 0x608c(%rip), %rdi      # 0xbfd8
callq 0x21b0
movq %rax, -0x98(%rbp)
jmp 0x5f5a
movq -0x98(%rbp), %rdi
movq 0x6060(%rip), %rsi      # 0xbfc8
callq 0x2200
jmp 0x5f6f
leaq -0x38(%rbp), %rdi
callq 0x2140
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6390
movq %rax, -0x50(%rbp)
jmp 0x5efc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x60a6
movq 0x602b(%rip), %rdi      # 0xbfd8
leaq 0x235c(%rip), %rsi      # 0x8310
callq 0x21e0
movq %rax, %rdi
movq 0x6005(%rip), %rsi      # 0xbfc8
callq 0x2200
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x4ee0
movq %rax, -0x58(%rbp)
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x4f10
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5070
testb $0x1, %al
jne 0x6006
jmp 0x608a
leaq -0x58(%rbp), %rdi
callq 0x5100
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x43e0
movq -0xb0(%rbp), %rsi
movq 0x5fa8(%rip), %rdi      # 0xbfd8
callq 0x21b0
movq %rax, -0xa8(%rbp)
jmp 0x603e
movq -0xa8(%rbp), %rdi
movq 0x5f7c(%rip), %rsi      # 0xbfc8
callq 0x2200
jmp 0x6053
leaq -0x80(%rbp), %rdi
callq 0x2140
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x6390
movq %rax, -0x88(%rbp)
jmp 0x5fdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2140
jmp 0x60a6
movq 0x5f47(%rip), %rdi      # 0xbfd8
movq 0x5f30(%rip), %rsi      # 0xbfc8
callq 0x2200
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2300
nop
// File: killwing[P]PTree/./PTree.cpp
// Function: void PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::put<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
PTree<Key>::put(Path path, const T& value) {
    if (path.empty()) {
        return;
    }

    std::string p = path.pop();
    boost::any& a = data_[p];
    if (path.empty()) {
        a = value;
    } else {
        PTree* child = boost::any_cast<PTree>(&a);
        if (!child) {
            a = PTree(); // make a new tree
            child = boost::any_cast<PTree>(&a); // update
        }
        assert(child);
        child->put(path, value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0xf8(%rbp)
movq %rdi, %rax
movq -0xf8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
callq 0x72a0
testb $0x1, %al
jne 0x4625
jmp 0x462a
jmp 0x47c2
movq -0xf0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x72c0
movq -0xe8(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0x7360
movq %rax, -0x100(%rbp)
jmp 0x465d
movq -0xf0(%rbp), %rdi
movq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x72a0
movb %al, -0x109(%rbp)
jmp 0x467c
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0x4688
jmp 0x46ad
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x7440
jmp 0x4697
jmp 0x47b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x47cb
movq -0x40(%rbp), %rdi
callq 0x7490
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x4730
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x4510
movq -0x118(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x7500
jmp 0x46f8
leaq -0x90(%rbp), %rdi
callq 0x6420
movq -0x40(%rbp), %rdi
callq 0x7490
movq %rax, -0x58(%rbp)
jmp 0x4730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x6420
jmp 0x47cb
cmpq $0x0, -0x58(%rbp)
je 0x4739
jmp 0x4758
leaq 0x9a6e(%rip), %rdi      # 0xe1ae
leaq 0x9a6d(%rip), %rsi      # 0xe1b4
movl $0x8f, %edx
leaq 0x9a6d(%rip), %rcx      # 0xe1c0
callq 0x3130
movq -0xf0(%rbp), %rsi
movq -0x58(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x7550
jmp 0x4778
movq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0xe0(%rbp), %rsi
callq 0x45e0
jmp 0x4791
leaq -0xe0(%rbp), %rdi
callq 0x48e0
jmp 0x47b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x48e0
jmp 0x47cb
leaq -0x38(%rbp), %rdi
callq 0x3120
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xb7c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4c6d
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x30d0
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3370
movq -0x50(%rbp), %rdx
leaq 0x95f4(%rip), %rsi      # 0xe28b
leaq -0x30(%rbp), %rdi
callq 0x4530
jmp 0x4ca2
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb830
jmp 0x4cb1
movq -0x58(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x10f30(%rip), %rsi     # 0x15bf0
leaq 0x6ba9(%rip), %rdx      # 0xb870
callq 0x3350
jmp 0x4d16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4cf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
leaq -0x31(%rbp), %rdi
callq 0x3260
testb $0x1, -0x45(%rbp)
jne 0x4d02
jmp 0x4d0b
movq -0x58(%rbp), %rdi
callq 0x3180
jmp 0x4d0d
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x72c0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0xb950
movq %rax, -0xc0(%rbp)
jmp 0x4eb1
movq -0xd0(%rbp), %rdi
movq -0xc0(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xb9b0
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb980
testb $0x1, %al
jne 0x4ee2
jmp 0x4fc5
movq -0xd8(%rbp), %rdi
callq 0x72a0
movb %al, -0xd9(%rbp)
jmp 0x4ef6
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x4f02
jmp 0x4f23
movb $0x1, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x4fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4fe7
leaq -0x40(%rbp), %rdi
callq 0xba00
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb9e0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x4fb8
movq -0xd8(%rbp), %rsi
movq -0x68(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x7550
jmp 0x4f63
movq -0xe8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x4e60
movb %al, -0xe9(%rbp)
jmp 0x4f7e
movb -0xe9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x48e0
movl $0x1, -0x5c(%rbp)
jmp 0x4fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x48e0
jmp 0x4fe7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x4fd0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xbc80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5375
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x30d0
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3370
movq -0x58(%rbp), %rdx
leaq 0x8ee6(%rip), %rsi      # 0xe285
leaq -0x38(%rbp), %rdi
callq 0x4530
jmp 0x53aa
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb830
jmp 0x53b9
movq -0x60(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x10828(%rip), %rsi     # 0x15bf0
leaq 0x64a1(%rip), %rdx      # 0xb870
callq 0x3350
jmp 0x541e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x53f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
leaq -0x39(%rbp), %rdi
callq 0x3260
testb $0x1, -0x4d(%rbp)
jne 0x540a
jmp 0x5413
movq -0x60(%rbp), %rdi
callq 0x3180
jmp 0x5415
movq -0x48(%rbp), %rdi
callq 0x3360
nop
// File: killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::del(PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path)
void
PTree<Key>::del(Path path) {
    if (path.empty()) {
        return;
    }

    std::string p = path.pop();
    typename TreeType::iterator it = data_.find(p);
    if (path.empty()) {
        data_.erase(it);
    } else {
        PTree* child = boost::any_cast<PTree>(&(it->second));
        if (child) {
            child->del(path);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x72a0
testb $0x1, %al
jne 0x62a1
jmp 0x62a6
jmp 0x63ce
movq -0xc0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x72c0
movq -0xb8(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0xb550
movq %rax, -0xd0(%rbp)
jmp 0x62d9
movq -0xc0(%rbp), %rdi
movq -0xd0(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x72a0
movb %al, -0xd9(%rbp)
jmp 0x62f8
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x6304
jmp 0x6346
movq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0xdda0
movq %rax, -0xe8(%rbp)
jmp 0x6325
movq -0xe8(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x63c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x63d7
leaq -0x38(%rbp), %rdi
callq 0xb5b0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x7490
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x63c3
movq -0xc0(%rbp), %rsi
movq -0x60(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7550
jmp 0x6386
movq -0xf0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6260
jmp 0x639b
leaq -0xb0(%rbp), %rdi
callq 0x48e0
jmp 0x63c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x48e0
jmp 0x63d7
jmp 0x63c5
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x7580
testb $0x1, %al
jne 0x72ee
jmp 0x72f9
movq -0x40(%rbp), %rdi
callq 0x32e0
jmp 0x734b
movq -0x30(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x7600
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x30a0
movq -0x30(%rbp), %rdi
callq 0x7620
jmp 0x731d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7349
jmp 0x7340
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3120
jmp 0x7355
movq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x734b
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3360
nop