LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::put(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void KVStore::put(uint64_t key, const std::string &s) {
    std::clog << "+ " << key << " " << std::string(s, 0, 50) << std::endl;
    memTable->put(key, s);
    memTableSize += getDataSize(s.length());
    if (verbose) {
        // std::clog << "put " << key << '\t' << s << "  done.\n";
        // std::clog << *memTable << '\n';
    }
    // if the size memTable reaches the threshold, then calls buildSsTable and
    // resets memTable
    if (this->memTableSize >= MEM_TABLE_SIZE_MAX) {
        convertMemTable();
        resetMemTable();
        // std::clog << *memTable << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x9c3e(%rip), %r12      # 0xefa8
leaq 0x5f7f(%rip), %rsi      # 0xb2f0
movl $0x2, %edx
movq %r12, %rdi
callq 0x32b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %r12
leaq 0x5f5e(%rip), %rsi      # 0xb2f1
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
leaq 0x28(%rsp), %r13
movl $0x32, %ecx
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3070
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x32b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x540c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x38(%rbx), %r12
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x9582
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8670
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5455
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%r14), %rax
movq 0x30(%rbx), %rcx
addq %rcx, %rax
addq $0x28, %rax
movq %rax, 0x30(%rbx)
cmpq $0x1fffff, %rax         # imm = 0x1FFFFF
jbe 0x5480
movq %rbx, %rdi
callq 0x54ca
movq %rbx, %rdi
callq 0x59ae
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x54c1
movq 0x18(%rsp), %rsi
jmp 0x54b9
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54c1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::resetMemTable()
void KVStore::resetMemTable() {
    // resets memTable
    memTable.release();
    memTable = std::unique_ptr<SkipList<uint64_t, std::string>>(
        new SkipList<uint64_t, std::string>());
    // reset state
    memTableSize = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x38(%rdi)
movl $0x28, %edi
callq 0x3270
movq %rax, %r14
movq %rax, %rdi
callq 0x84ac
leaq 0x38(%rbx), %rdi
movq $0x0, (%rsp)
movq (%rdi), %rsi
movq %r14, (%rdi)
testq %rsi, %rsi
je 0x59ee
callq 0x93d4
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x59ff
movq %rsp, %rdi
callq 0x93d4
movq $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x3280
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::readPair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
std::string KVStore::readPair(std::string path, uint64_t offset) {
    std::ifstream fs(path, std::ios::binary);
    uint64_t len = 0;
    // 16 = key + time
    fs.seekg(offset + 16);
    fs.read(reinterpret_cast<char *>(&len), sizeof(len));
    char *tmp = new char[len + 1];
    fs.read(tmp, len);
    fs.close();
    tmp[len] = '\0';
    std::string val(tmp);
    delete[] tmp;
    // std::clog << "read " << len << " byte: " << val << std::endl;
    return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movl $0x4, %edx
callq 0x3370
movq $0x0, (%rsp)
addq $0x10, %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3300
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x32f0
movq (%rsp), %r15
leaq 0x1(%r15), %rdi
callq 0x3030
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x32f0
leaq 0x8(%rsp), %rdi
callq 0x3060
movq (%rsp), %rax
movb $0x0, (%r14,%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3140
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e24
movq %r14, %rdi
callq 0x3310
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5e91
jmp 0x5e91
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x70(%rsp), %rdi
movl $0x2, %edx
callq 0x8f3a
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
movl $0x1, %r15d
cmpl $0xa, %r14d
jb 0x66cf
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r14d, %ecx
cmpl $0x63, %ecx
jbe 0x66c6
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x66cc
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x66cf
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x6693
addl $-0x3, %r15d
jmp 0x66cf
addl $-0x2, %r15d
jmp 0x66cf
decl %r15d
movl %ebp, %r12d
shrl $0x1f, %r12d
leal (%r15,%r12), %esi
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x20(%rsp), %rdi
movl $0x2d, %edx
callq 0x32c0
movl %r12d, %edi
leaq 0x20(%rsp), %r12
addq (%r12), %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x94be
leaq 0x4c31(%rip), %rcx      # 0xb341
movl $0x6, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32a0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6748
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x674f
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x677e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $-0x1, %ebp
jne 0x679e
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x4bb7(%rip), %rcx      # 0xb348
movl $0x3, %r8d
xorl %esi, %esi
callq 0x3360
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
movl $0x2, %edx
callq 0x8f3a
leaq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x92b2
movq 0x20(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4e24
leaq 0x20(%rsp), %rdi
callq 0x8fba
leaq 0x48(%rsp), %rdi
callq 0x8fba
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x680a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x70(%rsp), %rdi
callq 0x8fba
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6849
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8fba
jmp 0x683d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8fba
jmp 0x684c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x687b
movq 0x10(%rsp), %rsi
jmp 0x686e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x687b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x687b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x8fba
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x80(%rsi), %rdi
callq 0x3090
testb %al, %al
je 0x6faf
addq $0x10, %r14
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3320
leaq 0x8(%rbx), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x3320
leaq 0x10(%rbx), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x3320
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3320
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x8293
xorl %esi, %esi
xorl %eax, %eax
addl (%rcx,%rsi,4), %eax
incq %rsi
cmpq %rsi, %rdi
jne 0x8286
jmp 0x8295
xorl %eax, %eax
addl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x1, 0x20(%rdi)
xorl %edi, %edi
callq 0x3230
movl %eax, %edi
callq 0x3240
movl $0x68, %edi
callq 0x3270
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq $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, -0x8(%rdi)
movq %rax, %rsi
callq 0x9612
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x8538
callq 0x9408
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8547
callq 0x9408
movl $0x68, %edi
callq 0x3270
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq $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, -0x8(%rdi)
movq %rax, %rsi
callq 0x9612
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0x85a9
callq 0x9408
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r15
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x85c0
callq 0x9408
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
movq %rax, 0x38(%rdi)
addq $0x40, %rdi
movq %r15, %rsi
callq 0x9478
movq (%rbx), %rax
movq 0x10(%rbx), %rdi
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
movq %r14, %rsi
callq 0x9478
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x85fa
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x860b
callq 0x9408
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8619
callq 0x9408
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x9d47
movq 0x528f(%rip), %rcx      # 0xefc8
cmpb $0x0, (%rcx)
je 0x9d43
incl 0x8(%rax)
jmp 0x9d47
lock
incl 0x8(%rax)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x9ebe
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x167f(%rip), %r12      # 0xb3e5
leaq 0x1584(%rip), %r13      # 0xb2f1
leaq 0x7(%rsp), %rbp
movq 0x38(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x9d9e
movq 0x5238(%rip), %rcx      # 0xefc8
cmpb $0x0, (%rcx)
je 0x9d9a
incl 0x8(%rax)
jmp 0x9d9e
lock
incl 0x8(%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32b0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x31d0
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32b0
movq 0x8(%rsp), %rsi
cmpq $0x0, 0x38(%rsi)
je 0x9e45
movq %rbx, %rdi
callq 0x31d0
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32b0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x31a0
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x32b0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x32b0
movq 0x8(%rsp), %rsi
movq 0x38(%rsi), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rsi
movq %r15, %rdi
callq 0x9478
jmp 0x9dcb
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32b0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31d0
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32b0
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x32b0
movq 0x18(%rsp), %rsi
movq 0x58(%rsi), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rsi
movq %r14, %rdi
callq 0x9478
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9eb0
callq 0x9408
movq 0x18(%rsp), %rax
testq %rax, %rax
jne 0x9d72
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x9ecd
callq 0x9408
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9ee1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9ef3
callq 0x9408
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x9f02
callq 0x9408
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/elarielcl[P]ArielsSequitur/Sequitur.cpp
// Function: main
int main(int argc, char **argv) {
  extern char *optarg;
  extern int optind, opterr;
  FILE *fp = stdin;

  int c;

  while ((c = getopt(argc, argv, "f:")) != -1) {
    switch (c) {
      case 'f':
      fp = fopen(optarg, "r");
      if (fp == NULL) {
        cerr << "Error oppening \"" << optarg << "\" file" << endl;
        exit(1);
      } break;
    }
  }

  SequiturGrammar grammar;
  while (!feof(fp)) {
    int c = fgetc(fp);
    if (c == EOF) break;
    grammar.put(c);
  }

  fprintf (stderr,"\nSequitur succeeded\n\n");
  fprintf (stderr,"Grammar\n\n");
  grammar.print();

  fprintf (stderr,"Original chars: %i\n",grammar.inputSize);
  fprintf (stderr,"Number of rules: %i\n",grammar.numberOfRules);
  fprintf (stderr,"Grammar Size: %i\n",grammar.grammarSize);
  fprintf (stderr,"Compression ratio: %0.2f%%\n",
			100.0*blog(grammar.M+grammar.numberOfRules)*grammar.grammarSize/(8.0*grammar.inputSize)); // In case we code the grammar with log |R|+|$\Sigma$| bits

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x3a80(%rip), %rax      # 0x5fc0
movq (%rax), %r13
leaq 0x1ace(%rip), %r15      # 0x4018
leaq 0x1aca(%rip), %r12      # 0x401b
movl %r14d, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2050
cmpl $0x66, %eax
je 0x256b
cmpl $-0x1, %eax
jne 0x2551
jmp 0x25cb
movq 0x3a3e(%rip), %rax      # 0x5fb0
movq (%rax), %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %r13
testq %rax, %rax
jne 0x2551
movq 0x3a64(%rip), %rdi      # 0x5ff0
leaq 0x1a8a(%rip), %rsi      # 0x401d
callq 0x20e0
movq 0x3a11(%rip), %rcx      # 0x5fb0
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x20e0
leaq 0x1a7d(%rip), %rsi      # 0x402e
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2070
movl $0x1, %edi
callq 0x2130
movq %r13, %rdi
callq 0x21e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26fa
movq %rdi, %rbx
movl $0x20, %edi
callq 0x20f0
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
movl %r15d, %edx
callq 0x35e0
movq (%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x362c
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x362c
cmpl $0x2, 0x14(%rbx)
jl 0x26ef
movq 0x8(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28ec
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38c7(%rip), %rdi      # 0x5fc8
leaq 0x19a4(%rip), %rsi      # 0x40ac
callq 0x20e0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2190
leaq 0x19a4(%rip), %rsi      # 0x40c3
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2070
xorl %edi, %edi
callq 0x2130
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
addl %esi, %eax
decl %eax
cvtsi2ss %rax, %xmm0
movl %eax, 0x10(%rdi)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x27a7
sqrtss %xmm0, %xmm0
jmp 0x27ac
callq 0x21b0
cvttss2si %xmm0, %esi
cmpl $0x4, %esi
jl 0x27f5
movl 0x10(%r14), %ecx
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
cmpl $0x55555556, %eax       # imm = 0x55555556
jb 0x27e6
movl $0x5, %r8d
cmpl %esi, %r8d
setl %dil
jge 0x27f5
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
addl $0x2, %r8d
testl %edx, %edx
jne 0x27cc
jmp 0x27e9
movb $0x1, %dil
addl $-0x2, %ecx
movl %ecx, 0x10(%r14)
testb %dil, %dil
jne 0x27b9
movl 0x10(%r14), %edi
shlq $0x3, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
movl $0x20, %edi
callq 0x20f0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x35e0
movq %r15, 0x18(%r14)
movq %rbx, (%r14)
movl $0x0, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x35f8
xorl %edx, %edx
divl 0x10(%r14)
movl %edx, %r15d
movslq (%rbx), %r12
imulq $0x78787879, %r12, %rax # imm = 0x78787879
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rax
addl %ecx, %eax
movl %eax, %ecx
shll $0x4, %ecx
addl %eax, %ecx
subl %ecx, %r12d
movq 0x8(%r14), %rax
movslq %r15d, %r13
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x28b3
callq 0x35ec
testb %al, %al
je 0x28c3
movq 0x8(%r14), %rax
movq %rbx, (%rax,%r13,8)
incl 0x14(%r14)
xorl %eax, %eax
jmp 0x28d8
subl %r12d, %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%r14)
movb $0x1, %al
movl %edx, %r15d
testb %al, %al
jne 0x289a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x35f8
xorl %edx, %edx
divl 0x10(%r14)
movl %edx, %r15d
movq %rbx, -0x38(%rbp)
movslq (%rbx), %rdx
imulq $0x78787879, %rdx, %rax # imm = 0x78787879
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rax
addl %ecx, %eax
movl %eax, %ecx
shll $0x4, %ecx
addl %eax, %ecx
subl %ecx, %edx
movq %rdx, -0x40(%rbp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x8(%r14), %rax
movslq %r15d, %rbx
movq (%rax,%rbx,8), %r13
testq %r13, %r13
je 0x2f32
movq %r13, %rdi
callq 0x35ec
cmpl $-0x1, %r12d
sete %dl
movl %r15d, %ecx
testb %dl, %al
jne 0x2f48
movq %r13, %rdi
callq 0x35ec
testb %al, %al
jne 0x2f45
movq -0x38(%rbp), %rcx
movl (%rcx), %eax
cmpl (%r13), %eax
jne 0x2f45
movq 0x8(%rcx), %rax
movl (%rax), %eax
movq 0x8(%r13), %rcx
cmpl (%rcx), %eax
jne 0x2f45
shlq $0x3, %rbx
addq 0x8(%r14), %rbx
xorl %eax, %eax
movq %rbx, -0x30(%rbp)
jmp 0x2f73
cmpl $-0x1, %r12d
je 0x2f63
movslq %r12d, %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x2f71
movl %r12d, %ecx
subl -0x40(%rbp), %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%r14)
movb $0x1, %al
movl %ecx, %r12d
movl %edx, %r15d
jmp 0x2f73
leaq (%rax,%rbx,8), %rax
movq %rax, -0x30(%rbp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %eax, %eax
testb %al, %al
jne 0x2ed6
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x35f8
movq %rbx, %rsi
xorl %edx, %edx
divl 0x10(%r14)
movl %edx, %r15d
movslq (%rbx), %rdx
imulq $0x78787879, %rdx, %rax # imm = 0x78787879
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rax
addl %ecx, %eax
movl %eax, %ecx
shll $0x4, %ecx
addl %eax, %ecx
subl %ecx, %edx
movq %rdx, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
movq 0x8(%r14), %rax
movslq %r15d, %rbx
movq (%rax,%rbx,8), %r12
testq %r12, %r12
je 0x3097
movq %r12, %rdi
movq %rsi, %r13
callq 0x35ec
movq %r13, %rsi
testb %al, %al
jne 0x3032
movl (%rsi), %eax
cmpl (%r12), %eax
jne 0x3032
movq 0x8(%rsi), %rax
movl (%rax), %eax
movq 0x8(%r12), %rcx
cmpl (%rcx), %eax
jne 0x3032
movq %r12, %rdi
callq 0x3616
testb %al, %al
je 0x304a
xorl %eax, %eax
movq -0x30(%rbp), %rsi
jmp 0x3099
subl -0x38(%rbp), %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%r14)
movb $0x1, %al
movl %edx, %r15d
jmp 0x3099
movq -0x30(%rbp), %rsi
cmpq %rsi, %r12
jne 0x3087
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x35ec
movq %r13, %rsi
testb %al, %al
jne 0x3087
movl (%r12), %ecx
movq 0x8(%r12), %rax
cmpl (%rax), %ecx
jne 0x3087
movq 0x8(%rax), %rdx
cmpl (%rdx), %ecx
jne 0x3087
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
jmp 0x3097
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq %rcx, (%rax,%rbx,8)
decl 0x14(%r14)
xorl %eax, %eax
testb %al, %al
jne 0x2fe1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f00(%rip), %r14      # 0x5fc8
leaq 0x1003(%rip), %rsi      # 0x40d2
movl $0x5, %edx
movq %r14, %rdi
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
cmpl $0x0, 0x10(%rbx)
je 0x3178
xorl %r13d, %r13d
leaq 0xfc5(%rip), %r15       # 0x40d8
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x312c
movq %r12, %rdi
callq 0x35ec
testb %al, %al
je 0x3165
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
jmp 0x316d
movq %r12, %rdi
callq 0x3762
incq %r13
movl 0x10(%rbx), %eax
cmpq %rax, %r13
jb 0x3113
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rbx
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
movl %esi, 0xc(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x20, %edi
callq 0x20f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x35e0
movq %r15, %rdi
movq %r15, %rsi
callq 0x362c
movq %r15, (%r14)
movq %rbx, 0x2f38(%rip)      # 0x6110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x1, 0x10(%rdi)
movq 0x2d9e(%rip), %rdi      # 0x5fc8
leaq 0xeb0(%rip), %rsi       # 0x40e1
movl $0x1, %edx
callq 0x2110
movl 0xc(%rbx), %esi
movq 0x2ecb(%rip), %rax      # 0x6110
subl 0x20(%rax), %esi
movq 0x2d79(%rip), %rdi      # 0x5fc8
callq 0x2190
movq 0x2d6d(%rip), %rdi      # 0x5fc8
leaq 0xe81(%rip), %rsi       # 0x40e3
movl $0x2, %edx
callq 0x2110
movq (%rbx), %r14
movq 0x2d52(%rip), %rbx      # 0x5fc8
leaq -0x29(%rbp), %r15
leaq 0xe8c(%rip), %r12       # 0x410d
leaq 0xe59(%rip), %r13       # 0x40e1
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x35ec
testb %al, %al
jne 0x333c
movl (%r14), %eax
movq 0x2e6a(%rip), %rcx      # 0x6110
cmpl 0x20(%rcx), %eax
jge 0x32d0
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
jmp 0x3288
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2110
movl (%r14), %esi
movq 0x2e26(%rip), %rax      # 0x6110
subl 0x20(%rax), %esi
movq %rbx, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
movq 0x18(%r14), %rax
cmpb $0x0, 0x10(%rax)
jne 0x3288
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x332a
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x3288
leaq 0x18(%r14), %rdx
leaq -0x50(%rbp), %rdi
callq 0x34a0
jmp 0x3288
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq 0x2c6e(%rip), %rdi      # 0x5fc8
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq -0x50(%rbp), %rdi
cmpq %rdi, -0x48(%rbp)
je 0x3399
xorl %ebx, %ebx
movq (%rdi,%rbx,8), %rdi
cmpb $0x0, 0x10(%rdi)
jne 0x3382
callq 0x31fc
incq %rbx
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rbx, %rax
ja 0x3373
testq %rdi, %rdi
je 0x33aa
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33bf
jmp 0x33bf
jmp 0x33bf
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x33d7
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rax), %rbx
movq %rbx, %rdi
callq 0x35ec
testb %al, %al
jne 0x3444
movq 0x2bc4(%rip), %r14      # 0x5fc8
leaq -0x19(%rbp), %r15
movl (%rbx), %eax
movq 0x2cff(%rip), %rcx      # 0x6110
cmpl 0x20(%rcx), %eax
jge 0x342b
movb %al, -0x19(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2110
jmp 0x3434
movq 0x18(%rbx), %rdi
callq 0x33e0
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x35ec
testb %al, %al
je 0x3408
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x8(%rax), %r14
movq %r14, %rdi
callq 0x35ec
testb %al, %al
jne 0x349b
movl (%r14), %eax
movq 0x2c99(%rip), %rcx      # 0x6110
cmpl 0x20(%rcx), %eax
jge 0x3489
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20b0
jmp 0x3495
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x3450
movq 0x8(%r14), %r14
jmp 0x3461
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $-0x1, (%rdi)
je 0x365a
movq 0x8(%r14), %r14
cmpl $-0x1, (%r14)
jne 0x3650
movq 0x2967(%rip), %rbx      # 0x5fc8
leaq 0xa98(%rip), %rsi       # 0x4100
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2110
movq 0x18(%r14), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x2190
leaq 0xa81(%rip), %rsi       # 0x410c
movl $0x2, %edx
movq %rax, %rdi
callq 0x2110
movq 0x18(%r14), %rax
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0x2190
leaq 0xa61(%rip), %rsi       # 0x410f
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2110
movq 0x8(%r14), %r13
movl (%r13), %esi
cmpl $-0x1, %esi
je 0x3724
leaq 0x2a41(%rip), %rbx      # 0x6110
movq 0x28f2(%rip), %r14      # 0x5fc8
leaq -0x29(%rbp), %r15
leaq 0xa2c(%rip), %r12       # 0x410d
movq (%rbx), %rax
cmpl 0x20(%rax), %esi
jge 0x36ff
movb %sil, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2110
jmp 0x3707
movq %r14, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
movq 0x8(%r13), %r13
movl (%r13), %esi
cmpl $-0x1, %esi
jne 0x36e1
movq 0x289d(%rip), %rbx      # 0x5fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x2997(%rip), %r14      # 0x6110
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x379e
leaq -0x11(%rbp), %rax
movb %sil, (%rax)
movq 0x2839(%rip), %rdi      # 0x5fc8
movl $0x1, %edx
movq %rax, %rsi
callq 0x2110
jmp 0x37aa
movq 0x2823(%rip), %rdi      # 0x5fc8
callq 0x2190
leaq 0x963(%rip), %rsi       # 0x4114
movl $0x1, %edx
movq %rax, %rdi
callq 0x2110
movq 0x8(%rbx), %rax
movl (%rax), %esi
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x37e9
leaq -0x12(%rbp), %rax
movb %sil, (%rax)
movq 0x27ee(%rip), %rdi      # 0x5fc8
movl $0x1, %edx
movq %rax, %rsi
callq 0x2110
jmp 0x37f5
movq 0x27d8(%rip), %rdi      # 0x5fc8
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x20(%rsi), %r13
movq 0x28(%rsi), %r12
cmpq %r12, %r13
je 0x109d5
movq %rdx, %r14
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq (%r13), %rsi
leaq -0x50(%rbp), %rdi
callq 0xb78e
movq -0x48(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x10992
testq %rdx, %rdx
je 0x10997
movq (%r14), %rsi
movq -0x50(%rbp), %rdi
callq 0x41e0
testl %eax, %eax
sete %r15b
jmp 0x1099a
xorl %r15d, %r15d
jmp 0x1099a
movb $0x1, %r15b
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x109b3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x41d0
testb %r15b, %r15b
je 0x109cc
movq (%r13), %rax
movq %rax, (%rbx)
leaq 0x8(%r13), %rsi
movq -0x30(%rbp), %rdi
callq 0x7c72
addq $0x10, %r13
cmpq %r12, %r13
jne 0x10962
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x109f8
callq 0x4eac
movq %r14, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarTratadorPeloNome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::shared_ptr<Funcionario> Petfera::pegarTratadorPeloNome(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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x20(%rsi), %r13
movq 0x28(%rsi), %r12
cmpq %r12, %r13
je 0x10aa5
movq %rdx, %r14
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq (%r13), %rsi
leaq -0x50(%rbp), %rdi
callq 0xb78e
movq -0x48(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x10a62
testq %rdx, %rdx
je 0x10a67
movq (%r14), %rsi
movq -0x50(%rbp), %rdi
callq 0x41e0
testl %eax, %eax
sete %r15b
jmp 0x10a6a
xorl %r15d, %r15d
jmp 0x10a6a
movb $0x1, %r15b
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x10a83
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x41d0
testb %r15b, %r15b
je 0x10a9c
movq (%r13), %rax
movq %rax, (%rbx)
leaq 0x8(%r13), %rsi
movq -0x30(%rbp), %rdi
callq 0x7c72
addq $0x10, %r13
cmpq %r12, %r13
jne 0x10a32
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x10ac8
callq 0x4eac
movq %r14, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::toPelo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pelos Petfera::toPelo(string key){
	if(key == "Ausente"){
		return ausente;
	}else if(key == "Reduzido"){
		return reduzido;
	}else{
		return normal;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x1e0e9(%rip), %rsi     # 0x2ec5b
movq %rbx, %rdi
callq 0x4090
testl %eax, %eax
je 0x10b9a
leaq 0x1e0de(%rip), %rsi     # 0x2ec63
movq %rbx, %rdi
callq 0x4090
cmpl $0x1, %eax
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0x10b9c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::inicio()
void Petfera::inicio()
{
	int escolha = 0;
	PetferaMenu(escolha);

	while (escolha != 11)
	{
		PetferaMenu(escolha);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
movq %r14, %rsi
callq 0x10c24
cmpl $0xb, (%r14)
je 0x10c1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c24
cmpl $0xb, -0x14(%rbp)
jne 0x10c09
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::removerAnimal()
void Petfera::removerAnimal()
{
	int id;

	cout << "Voce escolheu: Remover Animal.\n"
			 << endl;

	listarTodosAnimais();

	cout << "Numero de identificacao (id) do animal: ";
	cin >> id;
	int index = 0;

	for (auto &animal : this->animalStore)
	{
		if (animal->getId() == id)
		{
			this->animalStore.erase(this->animalStore.begin() + index);
		}

		index++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x29523(%rip), %r14     # 0x3afd0
leaq 0x1d228(%rip), %rsi     # 0x2ecdc
movl $0x1f, %edx
movq %r14, %rdi
callq 0x4210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x12998
leaq 0x1d205(%rip), %rsi     # 0x2ecfc
movl $0x28, %edx
movq %r14, %rdi
callq 0x4210
movq 0x294d5(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x11b50
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
callq 0x77f8
cmpl -0x24(%rbp), %eax
jne 0x11b3f
movq (%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x282d0
leaq (%r14,%r12), %rax
addq $0x10, %rax
addq $0x10, %r12
cmpq %r15, %rax
jne 0x11b23
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::removerFuncionario()
void Petfera::removerFuncionario()
{
	int id;

	cout << "Voce escolheu: Remover funcionario.\n"
			 << endl;

	listarTodosFuncaionarios();

	cout << "Numero de identificacao (id) do funcionario: ";
	cin >> id;

	int index = 0;

	for (auto &funcionario : this->funcionarioStore)
	{
		if (funcionario->getId() == id)
		{
			this->funcionarioStore.erase(this->funcionarioStore.begin() + index);
		}

		index++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x29459(%rip), %r14     # 0x3afd0
leaq 0x1d1a7(%rip), %rsi     # 0x2ed25
movl $0x24, %edx
movq %r14, %rdi
callq 0x4210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x11fdc
leaq 0x1d189(%rip), %rsi     # 0x2ed4a
movl $0x2d, %edx
movq %r14, %rdi
callq 0x4210
movq 0x2940b(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r15
cmpq %r15, %r14
je 0x11c1f
addq $0x20, %rbx
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
callq 0xb784
cmpl -0x24(%rbp), %eax
jne 0x11c0e
movq (%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x28372
leaq (%r14,%r12), %rax
addq $0x10, %rax
addq $0x10, %r12
cmpq %r15, %rax
jne 0x11bf2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::atualizar_dados_animal()
bool Petfera::atualizar_dados_animal()
{
	int id_animal;

	listarTodosAnimais();

	cout << "ID do animal a ser atualizado: ";
	cin >> id_animal;

	for (auto &animal : this->animalStore)
	{
		if (id_animal == animal->getId())
		{
			atualizar_animal(animal);
		}
		else
		{
			cout << "ID nao encontrado, retornando...";
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x12998
movq 0x29384(%rip), %rdi     # 0x3afd0
leaq 0x1d023(%rip), %rsi     # 0x2ec76
movl $0x1f, %edx
callq 0x4210
movq 0x2937c(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x11cf4
movq 0x29350(%rip), %r14     # 0x3afd0
leaq 0x1d00f(%rip), %r15     # 0x2ec96
movl -0x2c(%rbp), %ebx
movq (%r12), %rdi
callq 0x77f8
cmpl %eax, %ebx
jne 0x11cbe
movq (%r12), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%r12), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x11cd4
movq 0x29314(%rip), %rcx     # 0x3afc8
cmpb $0x0, (%rcx)
je 0x11cd0
incl 0x8(%rax)
jmp 0x11cd4
movl $0x20, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
jmp 0x11ceb
lock
incl 0x8(%rax)
leaq -0x40(%rbp), %rsi
callq 0x1c75e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11ceb
callq 0x4eac
addq $0x10, %r12
cmpq %r13, %r12
jne 0x11c87
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11d16
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarAnimaisPorFunca()
void Petfera::listarAnimaisPorFunca()
{
	int id;
	listarTodosFuncaionarios();
	cout << "Por favor escolha o id do funcionario que voce quer listar os animais atribuidos a ele"
			 << "\n";
	cin >> id;
	for (auto &&animal : this->animalStore)
	{
		if (animal->getVeterinario()->getId() == id)
		{
			cout << *(animal) << "\n";
		}
		if (animal->getTratador()->getId() == id)
		{
			cout << *(animal) << "\n";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x11fdc
movq 0x29292(%rip), %r14     # 0x3afd0
leaq 0x1c1ac(%rip), %rsi     # 0x2def1
movl $0x56, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1bcd8(%rip), %rsi     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
callq 0x4210
movq 0x29273(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq (%rbx), %r13
movq 0x8(%rbx), %r14
cmpq %r14, %r13
je 0x11e3d
leaq -0x40(%rbp), %rbx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x7868
movq -0x40(%rbp), %rdi
callq 0xb784
movl %eax, %r12d
movl -0x2c(%rbp), %r15d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11db4
callq 0x4eac
cmpl %r15d, %r12d
jne 0x11ddd
movq (%r13), %rsi
movq 0x2920c(%rip), %rdi     # 0x3afd0
callq 0x7a1b
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1bc59(%rip), %rsi     # 0x2da31
callq 0x4210
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x789a
movq -0x40(%rbp), %rdi
callq 0xb784
movl %eax, %r12d
movl -0x2c(%rbp), %r15d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11e07
callq 0x4eac
cmpl %r15d, %r12d
jne 0x11e30
movq (%r13), %rsi
movq 0x291b9(%rip), %rdi     # 0x3afd0
callq 0x7a1b
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1bc06(%rip), %rsi     # 0x2da31
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x11d8a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11e4e
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11e5f
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
nop