LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdx, -0x278(%rbp)
movq %rsi, %rax
movq -0x278(%rbp), %rsi
movq %rdi, -0x270(%rbp)
movq %rdi, %rdx
movq %rdx, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x228(%rbp), %rdi
movl $0x4, %edx
callq 0x44c0
movq $0x0, -0x230(%rbp)
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
leaq -0x240(%rbp), %rdi
callq 0xcda0
jmp 0x819f
movq -0x240(%rbp), %rsi
movq -0x238(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x43f0
jmp 0x81bb
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
movl $0x8, %edx
callq 0x43e0
jmp 0x81d5
movq -0x230(%rbp), %rdi
incq %rdi
callq 0x4030
movq %rax, -0x280(%rbp)
jmp 0x81ed
movq -0x280(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rsi
movq -0x230(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x43e0
jmp 0x8217
leaq -0x228(%rbp), %rdi
callq 0x4070
jmp 0x8225
movq -0x258(%rbp), %rax
movq -0x230(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, -0x259(%rbp)
movq -0x258(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x25a(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x4540
movq -0x270(%rbp), %rdi
movq -0x290(%rbp), %rsi
movq -0x288(%rbp), %rdx
callq 0x5020
jmp 0x827b
leaq -0x25a(%rbp), %rdi
callq 0x4340
movq -0x258(%rbp), %rax
movq %rax, -0x298(%rbp)
cmpq $0x0, %rax
je 0x82a7
movq -0x298(%rbp), %rdi
callq 0x4400
movb $0x1, -0x259(%rbp)
testb $0x1, -0x259(%rbp)
jne 0x82f9
jmp 0x82ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x8315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x25a(%rbp), %rdi
callq 0x4340
jmp 0x8315
movq -0x270(%rbp), %rdi
callq 0x45d8
leaq -0x228(%rbp), %rdi
callq 0x40c0
movq -0x268(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x40c0
movq -0x248(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
movl $0x2, %edx
callq 0xc5a0
movl -0x14(%rbp), %esi
leaq -0x80(%rbp), %rdi
callq 0xd280
jmp 0x8b8b
leaq 0xd7e5(%rip), %rsi      # 0x16377
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0xd230
jmp 0x8ba1
leaq -0x80(%rbp), %rdi
callq 0x45d8
cmpl $-0x1, -0x14(%rbp)
jne 0x8c12
leaq 0xd7c7(%rip), %rsi      # 0x1637e
leaq -0x60(%rbp), %rdi
callq 0x4440
jmp 0x8bc2
jmp 0x8c12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8cd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x45d8
jmp 0x8cd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8ccf
leaq -0xe0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x2, %edx
callq 0xc5a0
jmp 0x8c29
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0xd3a0
jmp 0x8c42
movq -0xf0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xd420
jmp 0x8c57
leaq -0xb8(%rbp), %rdi
callq 0xc680
leaq -0xe0(%rbp), %rdi
callq 0xc680
leaq -0x60(%rbp), %rdi
callq 0x45d8
leaq -0x40(%rbp), %rdi
callq 0xc680
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8cc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xc680
leaq -0xe0(%rbp), %rdi
callq 0xc680
leaq -0x60(%rbp), %rdi
callq 0x45d8
leaq -0x40(%rbp), %rdi
callq 0xc680
movq -0x88(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4500
testb $0x1, %al
jne 0x95a3
jmp 0x961a
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x4420
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x4420
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movl $0x8, %edx
callq 0x4420
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x4160
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x4420
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x60, %rdi
callq 0xcd80
movq -0x38(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jae 0xb040
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb049
jmp 0xb070
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq -0x20(%rbp), %rsi
callq 0xdaf0
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb009
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0xf160
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x50(%rbp)
callq 0xf160
movq -0x48(%rbp), %rax
movl $0x1, 0x20(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x42d0
movl %eax, %edi
callq 0x42e0
movl $0x68, %edi
callq 0x4300
movq %rax, -0x40(%rbp)
jmp 0xb54c
movq -0x40(%rbp), %rdi
callq 0xf180
jmp 0xb557
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xf1f0
jmp 0xb566
movq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movq %rsi, -0x68(%rbp)
callq 0xf220
movq -0x68(%rbp), %rdi
callq 0xc8d0
movl $0x68, %edi
callq 0x4300
movq %rax, -0x60(%rbp)
jmp 0xb590
movq -0x60(%rbp), %rdi
callq 0xf180
jmp 0xb59b
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xf1f0
jmp 0xb5aa
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0xf220
leaq -0x38(%rbp), %rdi
callq 0xc8d0
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x70(%rbp)
callq 0xc7b0
movq -0x70(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rdi
callq 0xc7d0
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
callq 0xc7b0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0xc7d0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xb64f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0x4310
jmp 0xb64f
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0x4310
movq -0x50(%rbp), %rdi
callq 0xc8d0
movq -0x48(%rbp), %rdi
callq 0xc8d0
movq -0x20(%rbp), %rdi
callq 0x4530
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xc8a0
leaq -0x20(%rbp), %rdi
callq 0xc800
testb $0x1, %al
jne 0x10782
jmp 0x1091c
leaq -0x20(%rbp), %rdi
callq 0xc7b0
movq %rax, %rsi
addq $0x38, %rsi
leaq -0x30(%rbp), %rdi
callq 0xc8a0
movq -0x8(%rbp), %rdi
leaq 0x5c75(%rip), %rsi      # 0x1641b
callq 0x42f0
movq %rax, -0x48(%rbp)
jmp 0x107b1
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10950
movq %rax, -0x50(%rbp)
jmp 0x107c4
movq -0x50(%rbp), %rdi
leaq 0x5b58(%rip), %rsi      # 0x16327
callq 0x42f0
jmp 0x107d6
jmp 0x107d8
leaq -0x30(%rbp), %rdi
callq 0xc7b0
movq %rax, %rdi
addq $0x38, %rdi
callq 0xc800
testb $0x1, %al
jne 0x107f6
jmp 0x108aa
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10950
movq %rax, -0x58(%rbp)
jmp 0x10809
movq -0x58(%rbp), %rdi
leaq 0x5b13(%rip), %rsi      # 0x16327
callq 0x42f0
movq %rax, -0x60(%rbp)
jmp 0x1081f
leaq -0x30(%rbp), %rdi
callq 0xc7b0
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
callq 0x4090
movq %rax, -0x68(%rbp)
jmp 0x1083a
leaq -0x30(%rbp), %rdi
callq 0xc7b0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x42c0
movq %rax, -0x70(%rbp)
jmp 0x10859
movq -0x70(%rbp), %rdi
movl $0x9, %esi
callq 0x43a0
jmp 0x10869
leaq -0x30(%rbp), %rdi
callq 0xc7b0
movq %rax, %rsi
addq $0x38, %rsi
leaq -0x30(%rbp), %rdi
callq 0xc7d0
jmp 0x107d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc8d0
leaq -0x20(%rbp), %rdi
callq 0xc8d0
jmp 0x10940
movq -0x8(%rbp), %rdi
leaq 0x5b66(%rip), %rsi      # 0x1641b
callq 0x42f0
movq %rax, -0x78(%rbp)
jmp 0x108c0
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10950
movq %rax, -0x80(%rbp)
jmp 0x108d3
movq -0x80(%rbp), %rdi
leaq 0x5a49(%rip), %rsi      # 0x16327
callq 0x42f0
jmp 0x108e5
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x43a0
jmp 0x108f5
leaq -0x20(%rbp), %rdi
callq 0xc7b0
movq %rax, %rsi
addq $0x58, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc7d0
leaq -0x30(%rbp), %rdi
callq 0xc8d0
jmp 0x10770
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc8d0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x14(%rcx)
movl 0x10(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x10(%rcx)
movl -0xc(%rbp), %eax
cmpl 0x20(%rcx), %eax
jl 0x1794
movq 0x5870(%rip), %rdi      # 0x6fc8
leaq 0x294d(%rip), %rsi      # 0x40ac
callq 0x10c0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1180
movq %rax, %rdi
leaq 0x294a(%rip), %rsi      # 0x40c3
callq 0x10c0
movq %rax, %rdi
movq 0x5820(%rip), %rsi      # 0x6fa8
callq 0x10f0
xorl %edi, %edi
callq 0x1120
movl $0x20, %edi
callq 0x10d0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rsi
movl -0xc(%rbp), %edx
callq 0x35e0
jmp 0x17b9
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36a0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x36a0
movq -0x38(%rbp), %rax
cmpl $0x2, 0x14(%rax)
jl 0x182c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x1a90
jmp 0x182c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x10e0
jmp 0x1834
jmp 0x182e
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x18e9
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
cvtsi2ss %rax, %xmm0
callq 0x2740
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x3, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x193e
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
xorl %edx, %edx
divl -0x24(%rbp)
cmpl $0x0, %edx
jne 0x1931
movl $0x0, -0x20(%rbp)
jmp 0x193e
jmp 0x1933
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x190f
cmpl $0x0, -0x20(%rbp)
je 0x1946
jmp 0x1955
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x10(%rax)
jmp 0x1901
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x20, %edi
callq 0x10d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x35e0
jmp 0x1996
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x14(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x20, %esi
callq 0x10e0
movq -0x30(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3630
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl $0x11, %ecx
cltd
idivl %ecx
movl $0x11, %eax
subl %edx, %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a4f
movq -0x20(%rbp), %rdi
callq 0x3610
testb $0x1, %al
jne 0x1a4f
jmp 0x1a6e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x1a82
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x14(%rbp)
jmp 0x1a25
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x3630
movq -0x38(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl $0x11, %ecx
cltd
idivl %ecx
movl $0x11, %eax
subl %edx, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2485
cmpl $-0x1, -0x1c(%rbp)
jne 0x2469
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2507
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2507
movq -0x30(%rbp), %rdi
callq 0x3610
testb $0x1, %al
jne 0x2494
jmp 0x24a2
cmpl $-0x1, -0x1c(%rbp)
jne 0x24a2
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x24ee
movq -0x30(%rbp), %rdi
callq 0x3610
testb $0x1, %al
jne 0x24ec
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x24ec
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x24ec
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2507
jmp 0x24ee
jmp 0x24f0
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x20(%rbp)
jmp 0x242c
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3630
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl $0x11, %ecx
cltd
idivl %ecx
movl $0x11, %eax
subl %edx, %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2585
jmp 0x2675
movq -0x20(%rbp), %rdi
callq 0x3610
testb $0x1, %al
jne 0x265c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x265c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x265c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3660
testb $0x1, %al
jne 0x25d5
jmp 0x25da
jmp 0x2675
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x263b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x3610
testb $0x1, %al
jne 0x263b
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x263b
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x263b
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2658
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x265a
jmp 0x2675
jmp 0x265e
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, -0x14(%rbp)
jmp 0x2565
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x492d(%rip), %rdi      # 0x6fc8
leaq 0x1a30(%rip), %rsi      # 0x40d2
callq 0x10c0
movq %rax, %rdi
movq 0x48f7(%rip), %rsi      # 0x6fa8
callq 0x10f0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x272b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26fc
movq -0x18(%rbp), %rdi
callq 0x3610
testb $0x1, %al
jne 0x26fc
movq -0x18(%rbp), %rdi
callq 0x3810
jmp 0x271e
movq 0x48c5(%rip), %rdi      # 0x6fc8
leaq 0x19ce(%rip), %rsi      # 0x40d8
callq 0x10c0
movq %rax, %rdi
movq 0x488f(%rip), %rsi      # 0x6fa8
callq 0x10f0
jmp 0x2720
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26bd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x0, 0x10(%rax)
movl $0x20, %edi
callq 0x10d0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x35e0
jmp 0x27b0
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36a0
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x4925(%rip)      # 0x7100
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x20, %esi
callq 0x10e0
movq -0x28(%rbp), %rdi
callq 0x1190
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3610
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a4c
jmp 0x2a90
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq 0x46a7(%rip), %rcx      # 0x7100
cmpl 0x20(%rcx), %eax
jge 0x2a75
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq 0x455d(%rip), %rdi      # 0x6fc8
movsbl %al, %esi
callq 0x1100
jmp 0x2a82
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2a20
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a3b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3610
xorb $-0x1, %al
testb $0x1, %al
jne 0x2ad0
jmp 0x2b15
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq 0x4623(%rip), %rcx      # 0x7100
cmpl 0x20(%rcx), %eax
jge 0x2af6
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x1090
jmp 0x2b07
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2aa0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2abf
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3610
xorb $-0x1, %al
testb $0x1, %al
jne 0x36f5
jmp 0x3703
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x36e4
movq 0x38be(%rip), %rdi      # 0x6fc8
leaq 0x9ef(%rip), %rsi       # 0x4100
callq 0x10c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
callq 0x1180
movq %rax, %rdi
leaq 0x9d9(%rip), %rsi       # 0x410c
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rax), %esi
movq 0x387e(%rip), %rdi      # 0x6fc8
callq 0x1180
movq 0x3872(%rip), %rdi      # 0x6fc8
leaq 0x9b2(%rip), %rsi       # 0x410f
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3610
xorb $-0x1, %al
testb $0x1, %al
jne 0x377f
jmp 0x37e9
movq -0x18(%rbp), %rax
movl (%rax), %eax
leaq 0x3974(%rip), %rcx      # 0x7100
movq (%rcx), %rcx
cmpl 0x20(%rcx), %eax
jge 0x37ba
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq 0x3827(%rip), %rdi      # 0x6fc8
movsbl %al, %esi
callq 0x1100
movq %rax, %rdi
leaq 0x95a(%rip), %rsi       # 0x410d
callq 0x10c0
jmp 0x37db
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq 0x3801(%rip), %rdi      # 0x6fc8
callq 0x1180
movq %rax, %rdi
leaq 0x937(%rip), %rsi       # 0x410d
callq 0x10c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x376e
movq 0x37d8(%rip), %rdi      # 0x6fc8
movq 0x37b1(%rip), %rsi      # 0x6fa8
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl (%rax), %eax
leaq 0x38d3(%rip), %rcx      # 0x7100
movq (%rcx), %rcx
cmpl 0x20(%rcx), %eax
jge 0x385b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq 0x3786(%rip), %rdi      # 0x6fc8
movsbl %al, %esi
callq 0x1100
movq %rax, %rdi
leaq 0x8c0(%rip), %rsi       # 0x4114
callq 0x10c0
jmp 0x387c
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq 0x3760(%rip), %rdi      # 0x6fc8
callq 0x1180
movq %rax, %rdi
leaq 0x89d(%rip), %rsi       # 0x4114
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
leaq 0x3873(%rip), %rcx      # 0x7100
movq (%rcx), %rcx
cmpl 0x20(%rcx), %eax
jge 0x38bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq 0x3722(%rip), %rdi      # 0x6fc8
movsbl %al, %esi
callq 0x1100
movq %rax, %rdi
movq 0x36f0(%rip), %rsi      # 0x6fa8
callq 0x10f0
jmp 0x38e4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
movq 0x36f8(%rip), %rdi      # 0x6fc8
callq 0x1180
movq %rax, %rdi
movq 0x36c9(%rip), %rsi      # 0x6fa8
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x54892(%rip), %rsi     # 0x5bfb0
callq 0x41f0
movq %rax, %rdi
leaq 0x3ec63(%rip), %rsi     # 0x46390
callq 0x41c0
movq %rax, %rdi
leaq 0x3f265(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, %rdi
leaq 0x3e92f(%rip), %rsi     # 0x4607a
callq 0x41c0
movq %rax, %rdi
leaq 0x3ec60(%rip), %rsi     # 0x463ba
callq 0x41c0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7420
movq -0x88(%rbp), %rdi
callq 0x7950
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xaad0
jmp 0x7794
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x41b0
movq %rax, -0x98(%rbp)
jmp 0x77ad
movq -0x98(%rbp), %rdi
movq 0x547f5(%rip), %rsi     # 0x5bfb0
callq 0x41f0
movq %rax, -0xa0(%rbp)
jmp 0x77c9
movq -0xa0(%rbp), %rdi
leaq 0x3e8a3(%rip), %rsi     # 0x4607a
callq 0x41c0
movq %rax, -0xa8(%rbp)
jmp 0x77e5
movq -0xa8(%rbp), %rdi
leaq 0x3ebe0(%rip), %rsi     # 0x463d3
callq 0x41c0
movq %rax, -0xb0(%rbp)
jmp 0x7801
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x7450
movq -0xb8(%rbp), %rdi
callq 0x7950
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0xaad0
jmp 0x782f
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x41b0
movq %rax, -0xc0(%rbp)
jmp 0x7848
movq -0xc0(%rbp), %rdi
movq 0x5475a(%rip), %rsi     # 0x5bfb0
callq 0x41f0
jmp 0x785d
leaq -0x70(%rbp), %rdi
callq 0x4140
leaq -0x80(%rbp), %rdi
callq 0x5010
leaq -0x30(%rbp), %rdi
callq 0x4140
leaq -0x40(%rbp), %rdi
callq 0x5010
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x78e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x78df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x78d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4140
leaq -0x80(%rbp), %rdi
callq 0x5010
leaq -0x30(%rbp), %rdi
callq 0x4140
leaq -0x40(%rbp), %rdi
callq 0x5010
movq -0x48(%rbp), %rdi
callq 0x4320
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x4cf15(%rip), %rdi     # 0x5bfc8
leaq 0x38b15(%rip), %rsi     # 0x47bcf
callq 0x41c0
movq %rax, %rdi
leaq 0x378d8(%rip), %rsi     # 0x469a1
callq 0x41c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x22140
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7900
movq -0x78(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20840
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20870
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0xf169
jmp 0xf1f4
leaq -0x30(%rbp), %rdi
callq 0x208e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7950
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xaad0
jmp 0xf18d
movq -0x90(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x20950
movb %al, -0x91(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4140
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0xf1b8
jmp 0xf1e4
movq -0x88(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7920
jmp 0xf1e4
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x5010
jmp 0xf217
jmp 0xf1e6
leaq -0x30(%rbp), %rdi
callq 0x20930
jmp 0xf153
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf20a
movq -0x88(%rbp), %rdi
callq 0x5010
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4320
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7900
movq -0x78(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20840
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20870
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0xf299
jmp 0xf324
leaq -0x30(%rbp), %rdi
callq 0x208e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7950
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xaad0
jmp 0xf2bd
movq -0x90(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x20950
movb %al, -0x91(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4140
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0xf2e8
jmp 0xf314
movq -0x88(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7920
jmp 0xf314
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x5010
jmp 0xf347
jmp 0xf316
leaq -0x30(%rbp), %rdi
callq 0x20930
jmp 0xf283
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf33a
movq -0x88(%rbp), %rdi
callq 0x5010
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4320
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::toGenero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
t_genero Petfera::toGenero(string key){
	if(key == "Macho"){
		return M;
	}else{
		return F;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x36d80(%rip), %rsi     # 0x460f2
callq 0x1ec40
testb $0x1, %al
jne 0xf37d
jmp 0xf386
movl $0xa, -0x4(%rbp)
jmp 0xf38d
movl $0xb, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::toBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Petfera::toBool(string key){
	if(key == "sim"){
		return true;
	}else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x36d84(%rip), %rsi     # 0x46146
callq 0x1ec40
testb $0x1, %al
jne 0xf3cd
jmp 0xf3d3
movb $0x1, -0x1(%rbp)
jmp 0xf3d7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x4cbb5(%rip), %rdi     # 0x5bfc8
leaq 0x37f0c(%rip), %rsi     # 0x47326
callq 0x41c0
movq %rax, %rdi
leaq 0x37578(%rip), %rsi     # 0x469a1
callq 0x41c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x220d0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x38778(%rip), %rsi     # 0x47bee
callq 0x1ec40
testb $0x1, %al
jne 0xf481
jmp 0xf48a
movl $0x0, -0x4(%rbp)
jmp 0xf4b0
movq -0x20(%rbp), %rdi
leaq 0x38761(%rip), %rsi     # 0x47bf6
callq 0x1ec40
testb $0x1, %al
jne 0xf4a0
jmp 0xf4a9
movl $0x1, -0x4(%rbp)
jmp 0xf4b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::toGestacao(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TipoDeGestacao Petfera::toGestacao(string key){
	if(key == "Marsupial"){
		return marsupial;
	}else{
		return placentario;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x3871d(%rip), %rsi     # 0x47bff
callq 0x1ec40
testb $0x1, %al
jne 0xf4ed
jmp 0xf4f6
movl $0x0, -0x4(%rbp)
jmp 0xf4fd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xf580
cmpl $0xb, -0xc(%rbp)
je 0xf579
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xf580
jmp 0xf564
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x4bbed(%rip), %rdi     # 0x5bfc8
leaq 0x3788d(%rip), %rsi     # 0x47c6f
callq 0x41c0
movq %rax, %rdi
movq 0x4bbbf(%rip), %rsi     # 0x5bfb0
callq 0x41f0
movq -0x58(%rbp), %rdi
callq 0x11a40
movq 0x4bbc2(%rip), %rdi     # 0x5bfc8
leaq 0x37882(%rip), %rsi     # 0x47c8f
callq 0x41c0
movq 0x4bbc7(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x58(%rbp), %rax
movl $0x0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a60
testb $0x1, %al
jne 0x1045e
jmp 0x104d4
leaq -0x20(%rbp), %rdi
callq 0x20aa0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20ac0
movq %rax, %rdi
callq 0x7380
cmpl -0xc(%rbp), %eax
jne 0x104bd
movq -0x58(%rbp), %rdi
callq 0x20a00
movq %rax, -0x48(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x22250
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22290
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x221e0
movq %rax, -0x50(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20b10
jmp 0x1044b
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x4bacd(%rip), %rdi     # 0x5bfc8
leaq 0x377b6(%rip), %rsi     # 0x47cb8
callq 0x41c0
movq %rax, %rdi
movq 0x4ba9f(%rip), %rsi     # 0x5bfb0
callq 0x41f0
movq -0x58(%rbp), %rdi
callq 0x10a90
movq 0x4baa2(%rip), %rdi     # 0x5bfc8
leaq 0x377b0(%rip), %rsi     # 0x47cdd
callq 0x41c0
movq 0x4baa7(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x58(%rbp), %rax
movl $0x0, -0x10(%rbp)
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20840
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20870
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0x10585
jmp 0x1060a
leaq -0x20(%rbp), %rdi
callq 0x208e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7950
movq %rax, %rdi
callq 0xaab0
cmpl -0xc(%rbp), %eax
jne 0x105f3
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
callq 0x20840
movq %rax, -0x48(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x22340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22380
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x222d0
movq %rax, -0x50(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20930
jmp 0x1056f
addq $0x60, %rsp
popq %rbp
retq
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11a40
movq 0x4b998(%rip), %rdi     # 0x5bfc8
leaq 0x375d2(%rip), %rsi     # 0x47c09
callq 0x41c0
movq 0x4b99d(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a60
testb $0x1, %al
jne 0x10684
jmp 0x10716
leaq -0x20(%rbp), %rdi
callq 0x20aa0
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20ac0
movq %rax, %rdi
callq 0x7380
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jne 0x106f3
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1f130
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1d270
jmp 0x106d1
leaq -0x40(%rbp), %rdi
callq 0x1f160
jmp 0x10706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f160
jmp 0x10720
movq 0x4b8ce(%rip), %rdi     # 0x5bfc8
leaq 0x37528(%rip), %rsi     # 0x47c29
callq 0x41c0
jmp 0x10708
leaq -0x20(%rbp), %rdi
callq 0x20b10
jmp 0x1066e
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4320
nopl (%rax)