LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::del(unsigned long)
bool KVStore::del(uint64_t key) {
    std::clog << "- " << key << std::endl;
    std::string val = get(key);
    bool exists = false;
    std::shared_ptr<std::string> strVal(new std::string);

    uint64_t offset = 0;
    // exists in some ssTable
    if (findIndexedKey(key, &offset) != -1) {
        if (val != "") {
            put(key, "");
            exists = true;
        }else {
            exists = false;
        }
        // std::clog << "\tindexed" << std::endl;
    } else if (memTable->remove(key, strVal)) {
        this->memTableSize -= getDataSize((*strVal).length());
        exists = true;
        std::clog << "\tin mem" << std::endl;
    }
    if (!exists) std::clog << "x" << std::endl;
    return exists;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x9c7b(%rip), %rdi      # 0xefa8
leaq 0x4fcc(%rip), %rsi      # 0xa300
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x31b0
movq %rax, %rdi
callq 0x3160
movq (%rbx), %rax
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x8(%rax)
pushq $0x20
popq %rdi
callq 0x3280
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x835a
leaq 0x48(%rsp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5012
cmpl $-0x1, %eax
je 0x53ee
leaq 0x4f4d(%rip), %rsi      # 0xa2f2
leaq 0x50(%rsp), %rdi
callq 0x71c4
testb %al, %al
je 0x5457
leaq 0x4f34(%rip), %rsi      # 0xa2f2
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3992
movq (%rbx), %rax
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x28(%rsp), %rdi
callq 0x3438
movb $0x1, %bl
jmp 0x5474
movq 0x38(%rbx), %r15
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x77b2
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x71ce
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x77e6
testb %bpl, %bpl
je 0x5457
movq 0x8(%rsp), %rax
movq 0x30(%rbx), %rcx
subq 0x8(%rax), %rcx
addq $-0x28, %rcx
movq %rcx, 0x30(%rbx)
movq 0x9b69(%rip), %rdi      # 0xefa8
leaq 0x4ebd(%rip), %rsi      # 0xa303
callq 0x3270
movb $0x1, %bl
movq %rax, %rdi
callq 0x3160
jmp 0x5474
movq 0x9b4a(%rip), %rdi      # 0xefa8
leaq 0x4ea6(%rip), %rsi      # 0xa30b
callq 0x3270
movq %rax, %rdi
callq 0x3160
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x77e6
leaq 0x50(%rsp), %rdi
callq 0x3438
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3438
jmp 0x54bf
jmp 0x54bc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x77e6
jmp 0x54bf
movq %rax, %rbx
jmp 0x54c9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x77e6
leaq 0x50(%rsp), %rdi
callq 0x3438
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::reset()
void KVStore::reset() {
    // reset memTable
    resetMemTable();
    // Removes all existing ss-table
    int lv = 0;
    std::string level = resolvePath(lv);
    while (std::filesystem::exists(level)) {
        // std::clog << "remove " << level << std::endl;
        uintmax_t count = std::filesystem::remove_all(level);
        std::clog << "removed " << count << " file or directories" << std::endl;
        level = resolvePath(++lv);
        // std::clog << level << std::endl;
    }
    level = resolvePath(-1);
    if (std::filesystem::exists(level)) std::filesystem::remove_all(level);
    indexTableList.clear();
    fileNum.clear();
    fileNum.push_back(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x4e1c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5694
pushq $0x1
popq %rbp
movq %rsp, %r15
pushq $0x2
popq %r12
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x73a6
movq %r15, %rdi
callq 0x738a
movl %eax, %r13d
movq %r15, %rdi
callq 0x740e
testb %r13b, %r13b
je 0x55b1
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x73a6
movq %r15, %rdi
callq 0x3420
movq %rax, %r13
movq %r15, %rdi
callq 0x740e
movq 0x9a4c(%rip), %rdi      # 0xefa8
leaq 0x4daa(%rip), %rsi      # 0xa30d
callq 0x3270
movq %rax, %rdi
movq %r13, %rsi
callq 0x31b0
movq %rax, %rdi
leaq 0x4d99(%rip), %rsi      # 0xa316
callq 0x3270
movq %rax, %rdi
callq 0x3160
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5694
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq %r15, %rdi
callq 0x3438
incl %ebp
jmp 0x550e
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %rbx, %rsi
callq 0x5694
leaq 0x28(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq %r15, %rdi
callq 0x3438
movq %rsp, %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x73a6
movq %rsp, %rdi
callq 0x738a
movl %eax, %ebp
movq %rsp, %rdi
callq 0x740e
testb %bpl, %bpl
je 0x561f
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x73a6
movq %rsp, %rdi
callq 0x3420
movq %rsp, %rdi
callq 0x740e
leaq 0x40(%rbx), %rdi
callq 0x7424
leaq 0x60(%rbx), %rdi
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x563a
movq %rax, 0x68(%rbx)
movq %rsp, %rsi
andl $0x0, (%rsi)
callq 0x7bee
leaq 0x28(%rsp), %rdi
callq 0x3438
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5672
jmp 0x567f
jmp 0x567f
jmp 0x5672
jmp 0x567f
jmp 0x567f
jmp 0x567f
jmp 0x567f
jmp 0x5672
jmp 0x567f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x740e
jmp 0x5682
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3438
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::resolvePath[abi:cxx11](int) const
std::string KVStore::resolvePath(int level) const {
    std::filesystem::path root(this->dir);
    std::string lv = "level-" + std::to_string(level);
    if (level == -1) lv = "tmp";
    return std::filesystem::path(root / lv).string();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x70(%rsp), %rdi
pushq $0x2
popq %rdx
callq 0x73a6
movq %rsp, %rdi
movl %ebp, %esi
callq 0x75f3
leaq 0x4c7d(%rip), %rsi      # 0xa341
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
callq 0x75cf
movq %rsp, %rdi
callq 0x3438
cmpl $-0x1, %ebp
jne 0x56ef
leaq 0x4c63(%rip), %rsi      # 0xa348
leaq 0x28(%rsp), %rdi
callq 0x3400
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x73a6
movq %rsp, %rdi
leaq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x764c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7684
movq %rsp, %rdi
callq 0x740e
leaq 0x48(%rsp), %rdi
callq 0x740e
leaq 0x28(%rsp), %rdi
callq 0x3438
leaq 0x70(%rsp), %rdi
callq 0x740e
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
jmp 0x576f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x740e
jmp 0x5763
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x740e
jmp 0x5772
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x577f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3438
leaq 0x70(%rsp), %rdi
callq 0x740e
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rbx
jmp 0x5784
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::writeEntry(std::basic_fstream<char, std::char_traits<char>>&, Entry&)
void KVStore::writeEntry(std::fstream &fs, Entry &e) {
    if (!fs.is_open()) {
        // std::clog << "Error open file" << std::endl;
        return;
    }
    fs.write(reinterpret_cast<char *>(&e.key), sizeof(e.key));
    fs.write(reinterpret_cast<char *>(&e.timestamp), sizeof(e.timestamp));
    fs.write(reinterpret_cast<char *>(&e.len), sizeof(e.len));
    fs.write(e.str.c_str(), e.len);  // write val
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x80(%rsi), %rdi
callq 0x3080
testb %al, %al
je 0x5c5e
addq $0x10, %r14
pushq $0x8
popq %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3320
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3320
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3320
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3320
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::getIndex(int, int) const
int KVStore::getIndex(int level, int id) const {
    int index = 0;
    for (size_t i = 0; i < fileNum.size() && i < (size_t)level; i++) {
        index += fileNum[i];
    }
    index += id;
    return index;
}

// Assembly:
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movslq %esi, %rax
cmpq %rdi, %rax
cmovbq %rax, %rdi
xorl %eax, %eax
xorl %esi, %esi
cmpq %rsi, %rdi
je 0x69d8
addl (%rcx,%rsi,4), %eax
incq %rsi
jmp 0x69cb
addl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::merge(std::vector<Pair, std::allocator<Pair>>, std::vector<Pair, std::allocator<Pair>>)
std::vector<Pair> KVStore::merge(std::vector<Pair> a, std::vector<Pair> b) {
    std::vector<Pair> tmp;
    size_t i = 0, j = 0;
    while (i < a.size() && j < b.size()) {
        if (a[i].key < b[j].key)
            tmp.push_back(a[i++]);
        else if (a[i].key > b[j].key)
            tmp.push_back(b[j++]);
        else {
            // two entries with the same key, keeps the one with newer timestamp
            Pair p = a[i].time > b[j].time ? a[i] : b[j];
            tmp.push_back(p);
            i++;
            j++;
        }
    }
    while (i < a.size()) {
        tmp.push_back(a[i++]);
    }
    while (j < b.size()) {
        tmp.push_back(b[j++]);
    }
    // std::clog << "tmp merged: " << std::endl;
    // for (auto i : tmp) {
    //     std::clog << i.key << " " << i.val << std::endl;
    // }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
pushq $-0x1
popq %r13
xorl %ebp, %ebp
xorl %eax, %eax
xorl %r12d, %r12d
imulq $0x30, %r12, %rbx
movq %rax, 0x8(%rsp)
imulq $0x30, %rax, %rax
movq %rax, 0x10(%rsp)
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
cqto
pushq $0x30
popq %rsi
idivq %rsi
cmpq %rax, 0x8(%rsp)
jae 0x6ad1
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %rsi
cmpq %rax, %r12
jae 0x6ad1
movq 0x10(%rsp), %r8
leaq (%rcx,%r8), %rax
leaq (%rdi,%rbx), %rsi
movq (%rdi,%rbx), %rdx
cmpq %rdx, (%rcx,%r8)
jb 0x6a7c
jbe 0x6a8a
incq %r12
addq $0x30, %rbx
movq (%rsp), %rdi
callq 0x771e
jmp 0x6a1c
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x771e
jmp 0x6abd
movq 0x8(%rax), %rcx
cmpq 0x8(%rdi,%rbx), %rcx
cmovgq %rax, %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x7752
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x771e
incq %r12
leaq 0x28(%rsp), %rdi
callq 0x3438
movq 0x8(%rsp), %rax
incq %rax
addq $0x30, %rbp
incq %r13
jmp 0x6a0a
decq %r12
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
incq %r13
cmpq %rax, %r13
jae 0x6b00
addq %rbp, %rsi
addq $0x30, %rbp
movq (%rsp), %rdi
callq 0x771e
jmp 0x6ad4
pushq $0x30
popq %r15
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %r15
incq %r12
cmpq %rax, %r12
jae 0x6b2d
addq %rbx, %rsi
addq $0x30, %rbx
movq (%rsp), %rdi
callq 0x771e
jmp 0x6b04
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3438
jmp 0x6b5a
jmp 0x6b57
jmp 0x6b57
jmp 0x6b57
jmp 0x6b57
movq %rax, %r14
movq (%rsp), %rdi
callq 0x7516
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/./skiplist.h
// Function: SkipList<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::SkipList()
SkipList<Key, Value>::SkipList() : level(1) {
    srand(time(nullptr));
    head = std::shared_ptr<Node>(new Node());
    tail = std::shared_ptr<Node>(new Node());
    head->succ = tail;
    tail->pred = head;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x1, 0x20(%rdi)
xorl %edi, %edi
callq 0x3250
movl %eax, %edi
callq 0x3260
pushq $0x68
popq %rdi
callq 0x3280
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7ad2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7bc0
leaq 0x10(%rsp), %rdi
callq 0x77e6
pushq $0x68
popq %rdi
callq 0x3280
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7ad2
leaq 0x10(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7bc0
leaq 0x10(%rsp), %rdi
callq 0x77e6
movq (%rbx), %rdi
addq $0x38, %rdi
movq %r14, %rsi
callq 0x787c
movq 0x10(%rbx), %rdi
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x787c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x6c82
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x77e6
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x77e6
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/./skiplist.h
// Function: SkipList<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove(unsigned long, std::shared_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool SkipList<Key, Value>::remove(Key key, std::shared_ptr<Value> backupVal) {
    std::shared_ptr<Node> ptr = skipSearch(key);
    if (!valid(ptr) || ptr->key != key) return false;
    if (backupVal) *backupVal = ptr->val;
    while (ptr) {
        ptr->pred->succ = ptr->succ;
        ptr->succ->pred = ptr->pred;
        // if this level is empty and it's not bottom then delete it
        if (!ptr->pred->pred && !ptr->succ->succ && ptr->below) {
            if (head->succ == tail && tail->pred == head) {
                head = head->below;
                head->above = nullptr;
                tail = tail->below;
                tail->above = nullptr;
            }
        }
        ptr = ptr->below;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7dba
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x78e2
movq (%r13), %rax
testq %rax, %rax
je 0x734a
cmpq $0x0, 0x28(%rax)
je 0x734a
cmpq $0x0, 0x38(%rax)
je 0x734a
movq (%rsp), %rax
movq (%rax), %r12
leaq 0x30(%rsp), %rdi
callq 0x77e6
cmpq %r15, %r12
jne 0x7354
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7258
movq (%rsp), %rsi
addq $0x8, %rsi
callq 0x3180
leaq 0x10(%rbx), %r14
leaq 0x18(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %rsp, %rbp
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x7371
movq 0x28(%rsi), %rdi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x787c
movq (%rsp), %rsi
movq 0x38(%rsi), %rdi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x787c
movq (%rsp), %rsi
movq 0x28(%rsi), %rax
cmpq $0x0, 0x28(%rax)
jne 0x72bb
movq 0x38(%rsi), %rax
cmpq $0x0, 0x38(%rax)
je 0x72c9
addq $0x58, %rsi
movq %rbp, %rdi
callq 0x787c
jmp 0x726e
cmpq $0x0, 0x58(%rsi)
je 0x72bb
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, 0x38(%rax)
jne 0x72bb
cmpq %rax, 0x28(%rcx)
jne 0x72bb
addq $0x58, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x787c
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
addq $0x48, %rdi
movq %r13, %rsi
callq 0x7bc0
movq %r15, %rdi
callq 0x77e6
movq 0x10(%rbx), %rsi
addq $0x58, %rsi
movq %r14, %rdi
callq 0x787c
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %rdi
addq $0x48, %rdi
movq %r13, %rsi
callq 0x7bc0
movq %r12, %rdi
callq 0x77e6
movq (%rsp), %rsi
jmp 0x72bb
leaq 0x30(%rsp), %rdi
callq 0x77e6
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x77e6
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bl
jmp 0x7356
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x77e6
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/SeanChao[P]KV-Store/./skiplist.h
// Function: std::ostream& operator<<<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, SkipList<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
std::ostream& operator<<(std::ostream& os, const SkipList<Key, Value>& l) {
    std::shared_ptr<typename SkipList<Key, Value>::Node> vPtr = l.head;
    while (vPtr) {
        std::shared_ptr<typename SkipList<Key, Value>::Node> hPtr = vPtr->succ;
        os << "#" << vPtr << " ";
        while (hPtr->succ) {
            os << (hPtr) << " " << hPtr->key << hPtr->val << '\t';
            hPtr = hPtr->succ;
        }
        os << "#" << hPtr << " ";
        os << '\n';
        vPtr = vPtr->below;
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
callq 0x78e2
leaq 0x8(%rsp), %r12
leaq 0x233c(%rip), %r13      # 0xa3e5
leaq 0x2241(%rip), %rbp      # 0xa2f1
pushq $0x9
popq %r15
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x81a5
addq $0x38, %rsi
movq %r12, %rdi
callq 0x78e2
movq %r14, %rdi
movq %r13, %rsi
callq 0x3270
movq %rax, %rbx
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3270
movq 0x8(%rsp), %rsi
cmpq $0x0, 0x38(%rsi)
je 0x8152
movq %r14, %rdi
callq 0x31e0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3270
movq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x31b0
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movl %r15d, %esi
callq 0x32b0
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
movq %r12, %rdi
callq 0x787c
jmp 0x80f4
movq %r14, %rdi
movq %r13, %rsi
callq 0x3270
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3270
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x32b0
movq 0x18(%rsp), %rsi
addq $0x58, %rsi
leaq 0x18(%rsp), %rdi
callq 0x787c
leaq 0x10(%rsp), %rdi
callq 0x77e6
jmp 0x80b4
leaq 0x20(%rsp), %rdi
callq 0x77e6
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x81c3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x77e6
leaq 0x20(%rsp), %rdi
callq 0x77e6
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/SequiturGrammar.cpp
// Function: SequiturGrammar::put(int)
void SequiturGrammar::put(int c) {
  this->inputSize++;
  this->grammarSize++;

  if (c >= this->M){
    std::cout << "Encoding error, value " << c << " not supported"  << std::endl;
    exit(0);
  }else {
    Node* n = new Node(this->initialRule, c);
    Node* prevLast = this->initialRule->guard->prev;
    prevLast->connect(n);
    n->connect(this->initialRule->guard);
    
    if (this->inputSize >= 2) // when there are digrams
      this->index->putUnique(prevLast);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl 0x14(%rdi)
incl 0x10(%rdi)
movl %esi, %r15d
cmpl %esi, 0x20(%rdi)
jle 0x167c
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x10e0
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
movl %r15d, %edx
callq 0x240c
movq (%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2458
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2458
cmpl $0x2, 0x14(%rbx)
jl 0x1671
movq 0x8(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1812
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3945(%rip), %rdi      # 0x4fc8
leaq 0x1a22(%rip), %rsi      # 0x30ac
callq 0x10d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x1180
leaq 0x1a22(%rip), %rsi      # 0x30c3
movq %rax, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1080
xorl %edi, %edi
callq 0x1120
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::Dictionary(unsigned int, SequiturGrammar*)
Dictionary::Dictionary(const unsigned int n, SequiturGrammar* grammar) {
  // find a prime less than the maximum table size
  this->n = n;
  if (this->n % 2 == 0)
    this->n --;
  int max_factor = int(sqrt(float(this->n)));
  while (1) {
    int prime = 1;
    for (int i = 3; i < max_factor; i += 2)
     if (this->n % i == 0) {
        prime = 0;
         break;
     }
    if (prime)
     break;
    this->n -= 2;
  }

  this->table = new Node*[this->n];
  this->deleted = new Node(NULL); // A guard node represents a deleted  one in the table :D
  this->grammar = grammar;
  this->a = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
andl $0x1, %eax
leal (%rsi,%rax), %ecx
decl %ecx
movl %ecx, 0x10(%rdi)
cvtsi2ss %rcx, %xmm0
sqrtss %xmm0, %xmm0
cvttss2si %xmm0, %esi
pushq $0x3
popq %rdi
movl %edi, %r8d
cmpl %esi, %r8d
jge 0x1745
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
addl $0x2, %r8d
testl %edx, %edx
jne 0x1728
addl $-0x2, %ecx
movl %ecx, 0x10(%r14)
jmp 0x1725
movl %ecx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, 0x8(%r14)
pushq $0x20
popq %rdi
callq 0x10e0
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x240c
movq %r15, 0x18(%r14)
movq %rbx, (%r14)
andl $0x0, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::put(Node*)
void Dictionary::put(Node* node) {
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL || m->isGuard()) {
      this->table[i] = node;
      this->a++;
      break;
    }
    i = (i + jump) % this->n;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2424
xorl %edx, %edx
divl 0x10(%rbx)
movl %edx, %r15d
movl (%r14), %eax
pushq $0x11
popq %rcx
cltd
idivl %ecx
movl %edx, %r12d
movq 0x8(%rbx), %rax
movslq %r15d, %r13
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x17fb
callq 0x2418
testb %al, %al
jne 0x17f7
subl %r12d, %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%rbx)
movl %edx, %r15d
jmp 0x17ca
movq 0x8(%rbx), %rax
movq %r14, (%rax,%r13,8)
incl 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::get(Node*)
Node** Dictionary::get(Node* node) {
  int insertingIndex = -1;
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL)
      if (insertingIndex == -1)
        return &(this->table[i]);
      else
          return &(this->table[insertingIndex]);
    else if(m->isGuard() && insertingIndex == -1)
      insertingIndex = i;
    else if(!m->isGuard() && node->symbol == m->symbol && node->next->symbol==m->next->symbol) {
      return &(this->table[i]);
    }
    i = (i + jump) % this->n;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x2424
xorl %edx, %edx
divl 0x10(%r12)
movl %edx, %r15d
movq %r14, -0x38(%rbp)
movl (%r14), %eax
pushq $0x11
popq %rcx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
pushq $-0x1
popq %rcx
movq 0x8(%r12), %rax
movslq %r15d, %r13
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x1e3b
movl %ecx, -0x2c(%rbp)
cmpl $-0x1, %ecx
sete %bl
movq %r14, %rdi
callq 0x2418
movl %r15d, %ecx
testb %bl, %al
jne 0x1e24
movq %r14, %rdi
callq 0x2418
testb %al, %al
jne 0x1e21
movq -0x38(%rbp), %rcx
movl (%rcx), %eax
cmpl (%r14), %eax
jne 0x1e21
movq 0x8(%rcx), %rax
movl (%rax), %eax
movq 0x8(%r14), %rdx
movl -0x2c(%rbp), %ecx
cmpl (%rdx), %eax
jne 0x1e24
jmp 0x1e4f
movl -0x2c(%rbp), %ecx
subl -0x30(%rbp), %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%r12)
movl %edx, %r15d
jmp 0x1dce
cmpl $-0x1, %ecx
je 0x1e49
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %r13
jmp 0x1e58
leaq (%rax,%r13,8), %r13
jmp 0x1e58
shlq $0x3, %r13
addq 0x8(%r12), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::remove(Node*)
void Dictionary::remove(Node* node) {
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL) {
      return;
    }else if(!m->isGuard() && node->symbol == m->symbol && node->next->symbol==m->next->symbol) {
      if (m->digramOverlap(node)) return; // don't delete overlap occurence
      else if (m == node && !m->next->next->isGuard() && m->symbol == m->next->symbol && m->symbol == m->next->next->symbol) // change the table pointer if the digram already exists on the grammar
        this->table[i] = m->next;
      else {
        this->table[i] = deleted; // lazy deletion, open addressing
        this->a--;
      }
      return;
    }
    i = (i + jump) % this->n;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2424
xorl %edx, %edx
divl 0x10(%rbx)
movl %edx, %r12d
movq %r14, -0x30(%rbp)
movl (%r14), %eax
pushq $0x11
popq %rcx
cltd
idivl %ecx
movl %edx, %r13d
movq 0x8(%rbx), %rax
movslq %r12d, %r14
movq (%rax,%r14,8), %r15
testq %r15, %r15
je 0x1f42
movq %r15, %rdi
callq 0x2418
testb %al, %al
jne 0x1edb
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl (%r15), %eax
jne 0x1edb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq 0x8(%r15), %rcx
cmpl (%rcx), %eax
je 0x1eef
subl %r13d, %r12d
addl $0x11, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl 0x10(%rbx)
movl %edx, %r12d
jmp 0x1e9e
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x2442
testb %al, %al
jne 0x1f42
cmpq -0x30(%rbp), %r15
jne 0x1f33
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x2418
testb %al, %al
jne 0x1f33
movl (%r15), %ecx
movq 0x8(%r15), %rax
cmpl (%rax), %ecx
jne 0x1f33
movq 0x8(%rax), %rdx
cmpl (%rdx), %ecx
jne 0x1f33
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
jmp 0x1f42
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, (%rax,%r14,8)
decl 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::print()
void Dictionary::print() {
  std::cout << "INDEX" << std::endl;
  for (int i = 0; i < this->n; ++i) {
    Node* current = this->table[i];
    if (current && !current->isGuard())
      current->printDigram();
    else
     std::cout << "No value" << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x305e(%rip), %r14      # 0x4fc8
leaq 0x1161(%rip), %rsi      # 0x30d2
movq %r14, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1080
xorl %r13d, %r13d
leaq 0x114d(%rip), %r15      # 0x30d8
movl 0x10(%rbx), %eax
cmpq %rax, %r13
jae 0x1fce
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x1fac
movq %r12, %rdi
callq 0x2418
testb %al, %al
je 0x1fc1
movq %r14, %rdi
movq %r15, %rsi
callq 0x10d0
movq %rax, %rdi
callq 0x1080
jmp 0x1fc9
movq %r12, %rdi
callq 0x252a
incq %r13
jmp 0x1f8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Rule.cpp
// Function: Rule::Rule(int, SequiturGrammar*)
Rule::Rule(int c, SequiturGrammar* grammar):
symbol(c),
usage(0),
printed(false) {
  Node* guard = new Node(this);
  guard->connect(guard);
  this->guard = guard;
  this->grammar = grammar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
movq %rdx, %r14
movl %esi, 0xc(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x20
popq %rdi
callq 0x10e0
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x240c
movq %r15, %rdi
movq %r15, %rsi
callq 0x2458
movq %r15, (%rbx)
movq %r14, 0x30d7(%rip)      # 0x5100
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Rule.cpp
// Function: Rule::print()
void Rule::print() {
  std::vector<Rule*> v;
  this->printed = true;
  std::cout << "S" << this->symbol-this->grammar->M;
  std::cout << "->";
  Node* t = this->guard->next;
  while (!t->isGuard()) {
    if (t->symbol<this->grammar->M)
      std::cout <<  (char)t->symbol<< " ";
    else {
      std::cout <<  "S" << t->symbol-this->grammar->M << " ";
      if (!t->rule->printed)
        v.push_back(t->rule);
    }
    t = t->next;
  }
  std::cout << std::endl;
  for (int i = 0; i<v.size(); ++i)
    if (!v[i]->printed)v[i]->print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movb $0x1, 0x10(%rdi)
movq 0x2f53(%rip), %rdi      # 0x4fc8
leaq 0x1065(%rip), %rsi      # 0x30e1
callq 0x10d0
movl 0xc(%rbx), %esi
movq 0x3075(%rip), %rcx      # 0x5100
subl 0x20(%rcx), %esi
movq %rax, %rdi
callq 0x1180
movq 0x2f2b(%rip), %rdi      # 0x4fc8
leaq 0x103f(%rip), %rsi      # 0x30e3
callq 0x10d0
movq (%rbx), %rbx
movq 0x2f15(%rip), %r14      # 0x4fc8
leaq 0x1053(%rip), %r15      # 0x310d
leaq 0x1020(%rip), %r12      # 0x30e1
leaq -0x40(%rbp), %r13
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x2418
testb %al, %al
jne 0x213d
movl (%rbx), %eax
movq 0x3022(%rip), %rcx      # 0x5100
cmpl 0x20(%rcx), %eax
jge 0x20fb
movsbl %al, %esi
movq %r14, %rdi
callq 0x1100
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
jmp 0x20c5
movq %r14, %rdi
movq %r12, %rsi
callq 0x10d0
movl (%rbx), %esi
movq 0x2ff1(%rip), %rcx      # 0x5100
subl 0x20(%rcx), %esi
movq %rax, %rdi
callq 0x1180
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
movq 0x18(%rbx), %rax
cmpb $0x0, 0x10(%rax)
jne 0x20c5
leaq 0x18(%rbx), %rsi
movq %r13, %rdi
callq 0x223e
jmp 0x20c5
movq 0x2e84(%rip), %rdi      # 0x4fc8
callq 0x1080
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x2173
movq (%rax,%rbx,8), %rdi
cmpb $0x0, 0x10(%rdi)
jne 0x216e
callq 0x204a
incq %rbx
jmp 0x214b
leaq -0x40(%rbp), %rdi
callq 0x2270
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2191
jmp 0x2191
jmp 0x2191
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Rule.cpp
// Function: Rule::printUncompress()
void Rule::printUncompress() {
  Node* current = this->guard->next;
  while (!current->isGuard()) {
    if (current->symbol < this->grammar->M)
      std::cout << (char)current->symbol;
    else
      current->rule->printUncompress();
    current = current->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq 0x2e11(%rip), %r14      # 0x4fc8
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x2418
testb %al, %al
jne 0x21ed
movl (%rbx), %eax
movq 0x2f30(%rip), %rcx      # 0x5100
cmpl 0x20(%rcx), %eax
jge 0x21e2
movsbl %al, %esi
movq %r14, %rdi
callq 0x1100
jmp 0x21b7
movq 0x18(%rbx), %rdi
callq 0x21a6
jmp 0x21b7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Rule.cpp
// Function: Rule::getUncompress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Rule::getUncompress(std::string* s) {
  Node* current = this->guard->next;
  while (!current->isGuard()) {
    if (current->symbol < this->grammar->M)
      (*s)+= (char)current->symbol;
    else
      current->rule->getUncompress(s);
    current = current->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x2418
testb %al, %al
jne 0x2239
movl (%r14), %eax
movq 0x2ee7(%rip), %rcx      # 0x5100
cmpl 0x20(%rcx), %eax
jge 0x222b
movsbl %al, %esi
movq %rbx, %rdi
callq 0x10b0
jmp 0x21ff
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x21f2
jmp 0x21ff
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Node.cpp
// Function: Node::printRule()
void Node::printRule() {
  Node* guard = this;
  while (!guard->isGuard()) guard=guard->next;
  std::cout << "RULE USAGE=" << guard->rule->usage << ", ";
  std::cout << guard->rule->symbol;
  std::cout << " -> ";
  Node* t = guard->next;
  while (!t->isGuard()) {
    if (t->symbol<this->rule->grammar->M)
      std::cout <<  (char)t->symbol<< " ";
    else {
      std::cout <<  t->symbol<< " ";
    }
    t = t->next;
  }
  std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, (%rbx)
je 0x247f
movq 0x8(%rbx), %rbx
jmp 0x2474
movq 0x2b42(%rip), %r14      # 0x4fc8
leaq 0xc73(%rip), %rsi       # 0x3100
movq %r14, %rdi
callq 0x10d0
movq 0x18(%rbx), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1180
leaq 0xc61(%rip), %rsi       # 0x310c
movq %rax, %rdi
callq 0x10d0
movq 0x18(%rbx), %rax
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x1180
leaq 0xc46(%rip), %rsi       # 0x310f
movq %r14, %rdi
callq 0x10d0
leaq 0x2c28(%rip), %r12      # 0x5100
leaq 0xc2e(%rip), %r15       # 0x310d
movq 0x8(%rbx), %rbx
movl (%rbx), %esi
cmpl $-0x1, %esi
je 0x2516
movq (%r12), %rax
cmpl 0x20(%rax), %esi
jge 0x2501
movsbl %sil, %esi
movq %r14, %rdi
callq 0x1100
jmp 0x2509
movq %r14, %rdi
callq 0x1180
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
jmp 0x24df
movq 0x2aab(%rip), %rdi      # 0x4fc8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/elarielcl[P]ArielsSequitur/Node.cpp
// Function: Node::printDigram()
void Node::printDigram() {
  if (this->symbol < this->rule->grammar->M)
    std::cout << (char)this->symbol << ",";
  else
    std::cout << this->symbol << ",";

  if (this->next->symbol < this->rule->grammar->M)
    std::cout << (char)this->next->symbol << std::endl;
  else
    std::cout << this->next->symbol << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x2bc3(%rip), %r14      # 0x5100
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x2557
movsbl %sil, %esi
movq 0x2a78(%rip), %rdi      # 0x4fc8
callq 0x1100
jmp 0x2563
movq 0x2a6a(%rip), %rdi      # 0x4fc8
callq 0x1180
leaq 0xbaa(%rip), %rsi       # 0x3114
movq %rax, %rdi
callq 0x10d0
movq 0x8(%rbx), %rax
movl (%rax), %esi
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x2592
movsbl %sil, %esi
movq 0x2a3d(%rip), %rdi      # 0x4fc8
callq 0x1100
jmp 0x259e
movq 0x2a2f(%rip), %rdi      # 0x4fc8
callq 0x1180
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/Animal.cpp
// Function: operator<<(std::ostream&, Animal&)
std::ostream& operator<<(std::ostream& o, Animal& a) {
    o << std::endl
      << "============== Cuidadores ============== "
      << "\n" << "| "
      << "Veterinario           | "
      << a.getVeterinario()->getNome() << std::endl << "| "
      << "Tratador              | "
      << a.getTratador()->getNome() << std::endl;

    return a.imprimeDados(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40f0
leaq 0x18fb6(%rip), %rsi     # 0x1f390
movq %rax, %rdi
callq 0x41a0
leaq 0x19628(%rip), %rsi     # 0x1fa11
movq %rax, %rdi
callq 0x41a0
leaq 0x18c82(%rip), %rsi     # 0x1f07a
movq %rax, %rdi
callq 0x41a0
leaq 0x18fb3(%rip), %rsi     # 0x1f3ba
movq %rax, %rdi
callq 0x41a0
movq %rax, %r15
leaq 0x58(%r14), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x4bd0
movq (%r12), %rsi
leaq -0x80(%rbp), %rdi
callq 0x84b2
leaq -0x80(%rbp), %rsi
movq %r15, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
leaq 0x18c30(%rip), %rsi     # 0x1f07a
movq %rax, %rdi
callq 0x41a0
leaq 0x18f7a(%rip), %rsi     # 0x1f3d3
movq %rax, %rdi
callq 0x41a0
movq %rax, %r15
leaq 0x68(%r14), %rsi
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x4bd0
movq (%r12), %rsi
leaq -0x60(%rbp), %rdi
callq 0x84b2
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
leaq -0x60(%rbp), %rdi
callq 0x40e0
leaq -0x28(%rbp), %rdi
callq 0x4c0e
leaq -0x80(%rbp), %rdi
callq 0x40e0
leaq -0x38(%rbp), %rdi
callq 0x4c0e
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x64e7
movq %rax, %rbx
jmp 0x64fe
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x40e0
leaq -0x28(%rbp), %rdi
callq 0x4c0e
jmp 0x64f5
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x40e0
leaq -0x38(%rbp), %rdi
callq 0x4c0e
movq %rbx, %rdi
callq 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/FuncionarioTratador.cpp
// Function: FuncionarioTratador::imprimeDados(std::ostream&) const
std::ostream& FuncionarioTratador::imprimeDados(std::ostream& os) const {
    os << std::endl
       << "============== Funcionario_Tratador ==============" << std::endl << "| "
       << "ID                     | " << this->id << std::endl << "| "
       << "Classe                 | Funcionario" << std::endl<< "| "
       << "Nome                   | " << this->nome << std::endl<< "| "
       << "Numero contato         | " << this->celularProfissional << std::endl<< "| "
       << "Funcao                 | " << "Tratador" << std::endl<< "| "
       << "Cpf                    | " << this->cpf << std::endl<< "| "
       << "Email                  | " << this->email << std::endl<< "| "
       << "Nivel seguranca        | " << (this->classificacaoDeSeguranca == Verde ? "Verde" : this->classificacaoDeSeguranca == Azul ? "Azul" : "Vermelho") << std::endl<<" .";

    return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x40f0
leaq 0x17837(%rip), %rsi     # 0x1f640
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
leaq 0x1725a(%rip), %r15     # 0x1f07a
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17231(%rip), %rsi     # 0x1f063
movq %rax, %rdi
callq 0x41a0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17813(%rip), %rsi     # 0x1f673
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x1721c(%rip), %rsi     # 0x1f09e
movq %rax, %rdi
callq 0x41a0
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x177e8(%rip), %rsi     # 0x1f698
movq %rax, %rdi
callq 0x41a0
leaq 0x58(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x177d4(%rip), %rsi     # 0x1f6b2
movq %rax, %rdi
callq 0x41a0
leaq 0x18b71(%rip), %rsi     # 0x20a5e
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x177bd(%rip), %rsi     # 0x1f6cc
movq %rax, %rdi
callq 0x41a0
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x177a9(%rip), %rsi     # 0x1f6e6
movq %rax, %rdi
callq 0x41a0
leaq 0x78(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17795(%rip), %rsi     # 0x1f700
movq %rax, %rdi
callq 0x41a0
movl 0x98(%r14), %ecx
cmpl $0x6, %ecx
leaq 0x1779c(%rip), %rdx     # 0x1f720
leaq 0x1779a(%rip), %rdi     # 0x1f725
cmoveq %rdx, %rdi
cmpl $0x5, %ecx
leaq 0x17781(%rip), %rsi     # 0x1f71a
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
leaq 0x17236(%rip), %rsi     # 0x1f1ea
movq %rax, %rdi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/FuncionarioVeterinario.cpp
// Function: FuncionarioVeterinario::imprimeDados(std::ostream&) const
std::ostream& FuncionarioVeterinario::imprimeDados(std::ostream& os) const {
    os << std::endl
       << "============== Funcionario_Veterinario ==============" << std::endl << " " <<  "| "
       << "ID                     | " << this->id << std::endl<< "| "
       << "Classe                 | Funcionario" << std::endl<< "| "
       << "Nome                   | " << this->nome << std::endl<< "| "
       << "Numero contato         | " << this->celularProfissional << std::endl<< "| "
       << "Funcao                 | " << "Veterinario" << std::endl<< "| "
       << "Cpf                    | " << this->cpf << std::endl<< "| "
       << "Email                  | " << this->email << std::endl<< "| "
       << "Inscricao CRMV         | " << (this->isInscritoCRMV ? "Inscrito" : "Nao inscrito") << std::endl << " .";
    return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x40f0
leaq 0x175b3(%rip), %rsi     # 0x1f752
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
leaq 0x19847(%rip), %rsi     # 0x219fd
movq %rax, %rdi
callq 0x41a0
leaq 0x16eb5(%rip), %r15     # 0x1f07a
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x16e8c(%rip), %rsi     # 0x1f063
movq %rax, %rdi
callq 0x41a0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x1746e(%rip), %rsi     # 0x1f673
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x16e77(%rip), %rsi     # 0x1f09e
movq %rax, %rdi
callq 0x41a0
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17443(%rip), %rsi     # 0x1f698
movq %rax, %rdi
callq 0x41a0
leaq 0x58(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x1742f(%rip), %rsi     # 0x1f6b2
movq %rax, %rdi
callq 0x41a0
leaq 0x187e6(%rip), %rsi     # 0x20a78
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17418(%rip), %rsi     # 0x1f6cc
movq %rax, %rdi
callq 0x41a0
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17404(%rip), %rsi     # 0x1f6e6
movq %rax, %rdi
callq 0x41a0
leaq 0x78(%r14), %rsi
movq %rax, %rdi
callq 0x4190
movq %rax, %rdi
callq 0x40f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x17478(%rip), %rsi     # 0x1f788
movq %rax, %rdi
callq 0x41a0
leaq 0x17483(%rip), %rcx     # 0x1f7a2
leaq 0x17485(%rip), %rsi     # 0x1f7ab
cmpb $0x0, 0x98(%r14)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40f0
leaq 0x16ea1(%rip), %rsi     # 0x1f1ea
movq %rax, %rdi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::adicionarFuncionario(std::shared_ptr<Funcionario>)
bool Petfera::adicionarFuncionario(std::shared_ptr<Funcionario> novo_funcionario)
{
	cout << "Salvando funcionario"
			 << "\n";
	funcionarioStore.push_back(novo_funcionario);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x24446(%rip), %rdi     # 0x2efc8
leaq 0x16093(%rip), %rsi     # 0x20c1c
callq 0x41a0
leaq 0x14e7c(%rip), %rsi     # 0x1fa11
movq %rax, %rdi
callq 0x41a0
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13f4c
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarVeterinarioPeloNome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::shared_ptr<Funcionario> Petfera::pegarVeterinarioPeloNome(string nome)
{
	std::shared_ptr<Funcionario> novo;

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getNome() == nome)
		{
			novo = funcionario;
		}
	}
	return novo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq 0x20(%rsi), %r15
movq 0x28(%rsi), %rbx
leaq -0x50(%rbp), %r12
cmpq %rbx, %r15
je 0xac1b
movq (%r15), %rsi
movq %r12, %rdi
callq 0x84b2
movq %r12, %rdi
movq %r14, %rsi
callq 0x13945
movl %eax, %r13d
movq %r12, %rdi
callq 0x40e0
testb %r13b, %r13b
je 0xac15
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x6510
addq $0x10, %r15
jmp 0xabde
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x4c0e
movq %r14, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::adicionarAnimal(std::shared_ptr<Animal>)
bool Petfera::adicionarAnimal(std::shared_ptr<Animal> novo_animal)
{
	cout << "Salvando Animal"
			 << "\n";
	this->animalStore.push_back(novo_animal);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x242ac(%rip), %rdi     # 0x2efc8
leaq 0x15650(%rip), %rsi     # 0x20373
callq 0x41a0
leaq 0x14ce2(%rip), %rsi     # 0x1fa11
movq %rax, %rdi
callq 0x41a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13f10
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop