LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16ea
movq %rdi, %rbx
movl $0x20, %edi
callq 0x10f0
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
movl %r15d, %edx
callq 0x2568
movq (%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x25b4
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x25b4
cmpl $0x2, 0x14(%rbx)
jl 0x16df
movq 0x8(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38d7(%rip), %rdi      # 0x4fc8
leaq 0x19b4(%rip), %rsi      # 0x30ac
callq 0x10e0
movq %rax, %rdi
movl %r15d, %esi
callq 0x1190
leaq 0x19b4(%rip), %rsi      # 0x30c3
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
xorl %edi, %edi
callq 0x1130
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::Dictionary(unsigned int, SequiturGrammar*)
Dictionary::Dictionary(const unsigned int n, SequiturGrammar* grammar) {
  // find a prime less than the maximum table size
  this->n = n;
  if (this->n % 2 == 0)
    this->n --;
  int max_factor = int(sqrt(float(this->n)));
  while (1) {
    int prime = 1;
    for (int i = 3; i < max_factor; i += 2)
     if (this->n % i == 0) {
        prime = 0;
         break;
     }
    if (prime)
     break;
    this->n -= 2;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
andl $0x1, %eax
leal (%rsi,%rax), %ecx
decl %ecx
movl %ecx, 0x10(%rdi)
cvtsi2ss %rcx, %xmm0
sqrtss %xmm0, %xmm0
cvttss2si %xmm0, %esi
cmpl $0x4, %esi
jl 0x17b8
movl $0x3, %edi
movl %ecx, %eax
xorl %edx, %edx
divl %edi
testl %edx, %edx
je 0x17af
addl $0x2, %edi
cmpl %esi, %edi
jl 0x179c
jmp 0x17b8
addl $-0x2, %ecx
movl %ecx, 0x10(%r14)
jmp 0x1797
movl %ecx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, 0x8(%r14)
movl $0x20, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2568
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 0x1100
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::put(Node*)
void Dictionary::put(Node* node) {
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL || m->isGuard()) {
      this->table[i] = node;
      this->a++;
      break;
    }
    i = (i + jump) % this->n;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2580
xorl %edx, %edx
divl 0x10(%rbx)
movq 0x8(%rbx), %rcx
movslq %edx, %r13
movq (%rcx,%r13,8), %rdi
testq %rdi, %rdi
je 0x18a3
movl %edx, %r15d
movslq (%r14), %r12
callq 0x2574
movq 0x8(%rbx), %rcx
testb %al, %al
jne 0x18a3
imulq $0x78787879, %r12, %rax # imm = 0x78787879
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rax
addl %edx, %eax
movl %eax, %edx
shll $0x4, %edx
addl %eax, %edx
subl %edx, %r12d
subl %r12d, %r15d
addl $0x11, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl 0x10(%rbx)
movslq %edx, %r13
movq (%rcx,%r13,8), %rdi
testq %rdi, %rdi
je 0x18a3
movl %edx, %r15d
callq 0x2574
movq 0x8(%rbx), %rcx
testb %al, %al
je 0x1878
movq %r14, (%rcx,%r13,8)
incl 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::get(Node*)
Node** Dictionary::get(Node* node) {
  int insertingIndex = -1;
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL)
      if (insertingIndex == -1)
        return &(this->table[i]);
      else
          return &(this->table[insertingIndex]);
    else if(m->isGuard() && insertingIndex == -1)
      insertingIndex = i;
    else if(!m->isGuard() && node->symbol == m->symbol && node->next->symbol==m->next->symbol) {
      return &(this->table[i]);
    }
    i = (i + jump) % this->n;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2580
xorl %edx, %edx
divl 0x10(%rbx)
movq 0x8(%rbx), %rax
movslq %edx, %r15
movq (%rax,%r15,8), %r13
testq %r13, %r13
je 0x1f05
movl %edx, %r12d
movq %r14, -0x30(%rbp)
movslq (%r14), %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)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %r14d
movq %r13, %rdi
callq 0x2574
testb %al, %al
je 0x1ea6
movl %r12d, %ecx
cmpl $-0x1, %r14d
je 0x1ed4
movq %r13, %rdi
callq 0x2574
testb %al, %al
jne 0x1ed1
movq -0x30(%rbp), %rcx
movl (%rcx), %eax
cmpl (%r13), %eax
jne 0x1ed1
movq 0x8(%rcx), %rax
movl (%rax), %eax
movq 0x8(%r13), %rdx
movl %r14d, %ecx
cmpl (%rdx), %eax
jne 0x1ed4
jmp 0x1f1b
movl %r14d, %ecx
subl -0x38(%rbp), %r12d
addl $0x11, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl 0x10(%rbx)
movq 0x8(%rbx), %rax
movl %edx, %r12d
movslq %edx, %r15
movq (%rax,%r15,8), %r13
testq %r13, %r13
jne 0x1e8e
cmpl $-0x1, %ecx
je 0x1f05
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %r15
jmp 0x1f09
leaq (%rax,%r15,8), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0x3, %r15
addq 0x8(%rbx), %r15
jmp 0x1f09
nop
// File: /workspace/github_cpp_makefile_star2_O3/elarielcl[P]ArielsSequitur/Dictionary.cpp
// Function: Dictionary::remove(Node*)
void Dictionary::remove(Node* node) {
  int i = node->hashCode() % this->n;
  int jump = 17 - (node->symbol % 17); // open addressing, copied from craig
  while (1) {
    Node* m = this->table[i];
    if (m==NULL) {
      return;
    }else if(!m->isGuard() && node->symbol == m->symbol && node->next->symbol==m->next->symbol) {
      if (m->digramOverlap(node)) return; // don't delete overlap occurence
      else if (m == node && !m->next->next->isGuard() && m->symbol == m->next->symbol && m->symbol == m->next->next->symbol) // change the table pointer if the digram already exists on the grammar
        this->table[i] = m->next;
      else {
        this->table[i] = deleted; // lazy deletion, open addressing
        this->a--;
      }
      return;
    }
    i = (i + jump) % this->n;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x2580
xorl %edx, %edx
divl 0x10(%rbx)
movq 0x8(%rbx), %rax
movslq %edx, %r13
movq (%rax,%r13,8), %r15
testq %r15, %r15
je 0x1fcb
movl %edx, %r12d
movq -0x30(%rbp), %rax
movslq (%rax), %r14
imulq $0x78787879, %r14, %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, %r14d
movq %r15, %rdi
callq 0x2574
testb %al, %al
jne 0x1fa9
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl (%r15), %eax
jne 0x1fa9
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq 0x8(%r15), %rcx
cmpl (%rcx), %eax
je 0x1fda
subl %r14d, %r12d
addl $0x11, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl 0x10(%rbx)
movq 0x8(%rbx), %rax
movl %edx, %r12d
movslq %edx, %r13
movq (%rax,%r13,8), %r15
testq %r15, %r15
jne 0x1f80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x259e
testb %al, %al
jne 0x1fcb
cmpq -0x30(%rbp), %r15
jne 0x201e
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x2574
testb %al, %al
jne 0x201e
movl (%r15), %ecx
movq 0x8(%r15), %rax
cmpl (%rax), %ecx
jne 0x201e
movq 0x8(%rax), %rdx
cmpl (%rdx), %ecx
jne 0x201e
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x1fcb
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, (%rax,%r13,8)
decl 0x14(%rbx)
jmp 0x1fcb
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f80(%rip), %r14      # 0x4fc8
leaq 0x1083(%rip), %rsi      # 0x30d2
movl $0x5, %edx
movq %r14, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1090
cmpl $0x0, 0x10(%rbx)
je 0x20f8
xorl %r13d, %r13d
leaq 0x1045(%rip), %r15      # 0x30d8
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x20ac
movq %r12, %rdi
callq 0x2574
testb %al, %al
je 0x20e5
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1090
jmp 0x20ed
movq %r12, %rdi
callq 0x26ea
incq %r13
movl 0x10(%rbx), %eax
cmpq %rax, %r13
jb 0x2093
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2568
movq %r15, %rdi
movq %r15, %rsi
callq 0x25b4
movq %r15, (%r14)
movq %rbx, 0x2fb0(%rip)      # 0x5108
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e1e(%rip), %rdi      # 0x4fc8
leaq 0xf30(%rip), %rsi       # 0x30e1
movl $0x1, %edx
callq 0x1110
movl 0xc(%rbx), %esi
movq 0x2f43(%rip), %rax      # 0x5108
subl 0x20(%rax), %esi
movq 0x2df9(%rip), %rdi      # 0x4fc8
callq 0x1190
movq 0x2ded(%rip), %rdi      # 0x4fc8
leaq 0xf01(%rip), %rsi       # 0x30e3
movl $0x2, %edx
callq 0x1110
movq (%rbx), %r14
movq 0x2dd2(%rip), %rbx      # 0x4fc8
leaq -0x29(%rbp), %r15
leaq 0xf0c(%rip), %r12       # 0x310d
leaq 0xed9(%rip), %r13       # 0x30e1
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x2574
testb %al, %al
jne 0x22bc
movl (%r14), %eax
movq 0x2ee2(%rip), %rcx      # 0x5108
cmpl 0x20(%rcx), %eax
jge 0x2250
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1110
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
jmp 0x2208
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1110
movl (%r14), %esi
movq 0x2e9e(%rip), %rax      # 0x5108
subl 0x20(%rax), %esi
movq %rbx, %rdi
callq 0x1190
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
movq 0x18(%r14), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2208
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x22aa
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x2208
leaq 0x18(%r14), %rdx
leaq -0x50(%rbp), %rdi
callq 0x2428
jmp 0x2208
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq 0x2cee(%rip), %rdi      # 0x4fc8
callq 0x1040
movq %rax, %rdi
callq 0x1090
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rcx
cmpq %rdi, %rcx
je 0x2322
xorl %ebx, %ebx
movq (%rdi,%rbx,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2310
movq %rax, %rdi
callq 0x217c
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rcx
incq %rbx
movq %rcx, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rbx, %rax
ja 0x22f6
testq %rdi, %rdi
je 0x2333
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x1100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2348
jmp 0x2348
jmp 0x2348
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2360
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2574
testb %al, %al
jne 0x23cc
movq 0x2c3c(%rip), %r14      # 0x4fc8
leaq -0x19(%rbp), %r15
movl (%rbx), %eax
movq 0x2d6f(%rip), %rcx      # 0x5108
cmpl 0x20(%rcx), %eax
jge 0x23b3
movb %al, -0x19(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
jmp 0x23bc
movq 0x18(%rbx), %rdi
callq 0x2368
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x2574
testb %al, %al
je 0x2390
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2574
testb %al, %al
jne 0x2423
movl (%r14), %eax
movq 0x2d09(%rip), %rcx      # 0x5108
cmpl 0x20(%rcx), %eax
jge 0x2411
movsbl %al, %esi
movq %rbx, %rdi
callq 0x10b0
jmp 0x241d
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x23d8
movq 0x8(%r14), %r14
jmp 0x23e9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25e2
movq 0x8(%r14), %r14
cmpl $-0x1, (%r14)
jne 0x25d8
movq 0x29df(%rip), %rbx      # 0x4fc8
leaq 0xb10(%rip), %rsi       # 0x3100
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1110
movq 0x18(%r14), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x1190
leaq 0xaf9(%rip), %rsi       # 0x310c
movl $0x2, %edx
movq %rax, %rdi
callq 0x1110
movq 0x18(%r14), %rax
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0x1190
leaq 0xad9(%rip), %rsi       # 0x310f
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1110
movq 0x8(%r14), %r13
movl (%r13), %esi
cmpl $-0x1, %esi
je 0x26ac
leaq 0x2ab1(%rip), %rbx      # 0x5108
movq 0x296a(%rip), %r14      # 0x4fc8
leaq -0x29(%rbp), %r15
leaq 0xaa4(%rip), %r12       # 0x310d
movq (%rbx), %rax
cmpl 0x20(%rax), %esi
jge 0x2687
movb %sil, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
jmp 0x268f
movq %r14, %rdi
callq 0x1190
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
movq 0x8(%r13), %r13
movl (%r13), %esi
cmpl $-0x1, %esi
jne 0x2669
movq 0x2915(%rip), %rbx      # 0x4fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a07(%rip), %r14      # 0x5108
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x2726
leaq -0x11(%rbp), %rax
movb %sil, (%rax)
movq 0x28b1(%rip), %rdi      # 0x4fc8
movl $0x1, %edx
movq %rax, %rsi
callq 0x1110
jmp 0x2732
movq 0x289b(%rip), %rdi      # 0x4fc8
callq 0x1190
leaq 0x9db(%rip), %rsi       # 0x3114
movl $0x1, %edx
movq %rax, %rdi
callq 0x1110
movq 0x8(%rbx), %rax
movl (%rax), %esi
movq (%r14), %rax
cmpl 0x20(%rax), %esi
jge 0x2771
leaq -0x12(%rbp), %rax
movb %sil, (%rax)
movq 0x2866(%rip), %rdi      # 0x4fc8
movl $0x1, %edx
movq %rax, %rsi
callq 0x1110
jmp 0x277d
movq 0x2850(%rip), %rdi      # 0x4fc8
callq 0x1190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1090
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq 0x20(%rsi), %r15
movq 0x28(%rsi), %r12
cmpq %r12, %r15
je 0x10a2a
movq %rdx, %r14
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq (%r15), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb796
movq -0x50(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x109e4
movq -0x58(%rbp), %r13
testq %rdx, %rdx
je 0x109ec
movq (%r14), %rsi
movq %r13, %rdi
callq 0x41e0
testl %eax, %eax
sete %bl
jmp 0x109ee
movq -0x58(%rbp), %r13
xorl %ebx, %ebx
jmp 0x109ee
movb $0x1, %bl
leaq -0x48(%rbp), %rax
cmpq %rax, %r13
je 0x10a06
movq -0x48(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x41d0
testb %bl, %bl
je 0x10a21
movq (%r15), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x8(%r15), %rsi
movq -0x38(%rbp), %rdi
callq 0x7c76
addq $0x10, %r15
cmpq %r12, %r15
jne 0x109b3
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x10a51
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq 0x20(%rsi), %r15
movq 0x28(%rsi), %r12
cmpq %r12, %r15
je 0x10b0c
movq %rdx, %r14
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq (%r15), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb796
movq -0x50(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x10ac6
movq -0x58(%rbp), %r13
testq %rdx, %rdx
je 0x10ace
movq (%r14), %rsi
movq %r13, %rdi
callq 0x41e0
testl %eax, %eax
sete %bl
jmp 0x10ad0
movq -0x58(%rbp), %r13
xorl %ebx, %ebx
jmp 0x10ad0
movb $0x1, %bl
leaq -0x48(%rbp), %rax
cmpq %rax, %r13
je 0x10ae8
movq -0x48(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x41d0
testb %bl, %bl
je 0x10b03
movq (%r15), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x8(%r15), %rsi
movq -0x38(%rbp), %rdi
callq 0x7c76
addq $0x10, %r15
cmpq %r12, %r15
jne 0x10a95
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x10b33
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e07d(%rip), %rsi     # 0x2ec5b
movq %rbx, %rdi
callq 0x4090
testl %eax, %eax
je 0x10c06
leaq 0x1e072(%rip), %rsi     # 0x2ec63
movq %rbx, %rdi
callq 0x4090
cmpl $0x1, %eax
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0x10c08
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10c90
cmpl $0xb, (%r14)
je 0x10c86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c90
cmpl $0xb, -0x14(%rbp)
jne 0x10c75
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x294b7(%rip), %r14     # 0x3afd0
leaq 0x1d1bc(%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 0x12a0a
leaq 0x1d199(%rip), %rsi     # 0x2ecfc
movl $0x28, %edx
movq %r14, %rdi
callq 0x4210
movq 0x29469(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x11bbc
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
callq 0x77fc
cmpl -0x24(%rbp), %eax
jne 0x11bab
movq (%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x282de
leaq (%r14,%r12), %rax
addq $0x10, %rax
addq $0x10, %r12
cmpq %r15, %rax
jne 0x11b8f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x293ed(%rip), %r14     # 0x3afd0
leaq 0x1d13b(%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 0x12048
leaq 0x1d11d(%rip), %rsi     # 0x2ed4a
movl $0x2d, %edx
movq %r14, %rdi
callq 0x4210
movq 0x2939f(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r15
cmpq %r15, %r14
je 0x11c8b
addq $0x20, %rbx
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
callq 0xb78c
cmpl -0x24(%rbp), %eax
jne 0x11c7a
movq (%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x28380
leaq (%r14,%r12), %rax
addq $0x10, %rax
addq $0x10, %r12
cmpq %r15, %rax
jne 0x11c5e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12a0a
movq 0x29318(%rip), %rdi     # 0x3afd0
leaq 0x1cfb7(%rip), %rsi     # 0x2ec76
movl $0x1f, %edx
callq 0x4210
movq 0x29310(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x11d60
movq 0x292e4(%rip), %r14     # 0x3afd0
leaq 0x1cfa3(%rip), %r15     # 0x2ec96
movl -0x2c(%rbp), %ebx
movq (%r12), %rdi
callq 0x77fc
cmpl %eax, %ebx
jne 0x11d2a
movq (%r12), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%r12), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x11d40
movq 0x292a8(%rip), %rcx     # 0x3afc8
cmpb $0x0, (%rcx)
je 0x11d3c
incl 0x8(%rax)
jmp 0x11d40
movl $0x20, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
jmp 0x11d57
lock
incl 0x8(%rax)
leaq -0x40(%rbp), %rsi
callq 0x1c7c8
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11d57
callq 0x4eac
addq $0x10, %r12
cmpq %r13, %r12
jne 0x11cf3
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 0x11d82
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12048
movq 0x29226(%rip), %r14     # 0x3afd0
leaq 0x1c140(%rip), %rsi     # 0x2def1
movl $0x56, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1bc6c(%rip), %rsi     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
callq 0x4210
movq 0x29207(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq (%rbx), %r13
movq 0x8(%rbx), %r14
cmpq %r14, %r13
je 0x11ea9
leaq -0x40(%rbp), %rbx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x786c
movq -0x40(%rbp), %rdi
callq 0xb78c
movl %eax, %r12d
movl -0x2c(%rbp), %r15d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11e20
callq 0x4eac
cmpl %r15d, %r12d
jne 0x11e49
movq (%r13), %rsi
movq 0x291a0(%rip), %rdi     # 0x3afd0
callq 0x7a1f
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1bbed(%rip), %rsi     # 0x2da31
callq 0x4210
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x789e
movq -0x40(%rbp), %rdi
callq 0xb78c
movl %eax, %r12d
movl -0x2c(%rbp), %r15d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11e73
callq 0x4eac
cmpl %r15d, %r12d
jne 0x11e9c
movq (%r13), %rsi
movq 0x2914d(%rip), %rdi     # 0x3afd0
callq 0x7a1f
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1bb9a(%rip), %rsi     # 0x2da31
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x11df6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11eba
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11ecb
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarAnimaisPorClasse()
void Petfera::listarAnimaisPorClasse()
{
	int escolha;

	if (animalStore.size() == 0)
	{
		cout << "Sem animais cadastrados"
				 << "\n";
	};

	cout << "# Escolha uma das classes"
			 << "\n"
			 << "0 --> Mamiferos"
			 << "\n"
			 << "1 --> Aves"
			 << "\n"
			 << "2 --> Anfibios"
			 << "\n"
			 << "3 --> Repteis"
			 << "\n";

	cin >> escolha;

	for (auto &animal : animalStore)
	{
		if (animal->getFamilia() == escolha)
		{
			cout << *(animal) << "\n";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jne 0x11f1e
movq 0x290da(%rip), %r14     # 0x3afd0
leaq 0x1bf8a(%rip), %rsi     # 0x2de87
movl $0x17, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1bb20(%rip), %rsi     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
callq 0x4210
movq 0x290ab(%rip), %r14     # 0x3afd0
leaq 0x1bf73(%rip), %rsi     # 0x2de9f
movl $0x19, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1baf1(%rip), %r15     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bf62(%rip), %rsi     # 0x2deb9
movl $0xf, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bf4e(%rip), %rsi     # 0x2dec9
movl $0xa, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bf35(%rip), %rsi     # 0x2ded4
movl $0xe, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bf20(%rip), %rsi     # 0x2dee3
movl $0xd, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
movq 0x28ff9(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x1203b
movq 0x28fcd(%rip), %rbx     # 0x3afd0
leaq 0x1ba27(%rip), %r14     # 0x2da31
movq (%r15), %rdi
callq 0x79a8
cmpl -0x24(%rbp), %eax
jne 0x12032
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7a1f
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4210
addq $0x10, %r15
cmpq %r12, %r15
jne 0x1200a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarTodosFuncaionarios()
void Petfera::listarTodosFuncaionarios()
{

	ofstream arqCache_funcio("cache_funcio.dat");
	cout << "Aqui estao todo os Funcionários do Petfera"
			 << "\n\n";

	if (funcionarioStore.size() == 0)
	{
		cout << "Não temos nenhum funcionario em nosso Banco de dados, por favor, cadastre um funcionario"
				 << "\n"
				 << "retornando"
				 << "\n";

		inicio();
	}
	for (auto &novo : this->funcionarioStore)
	{
		cout << (*novo) << endl;
		arqCache_funcio << (*novo) << endl;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x1bee2(%rip), %rsi     # 0x2df48
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x41f0
movq 0x28f52(%rip), %rdi     # 0x3afd0
leaq 0x1bed4(%rip), %rsi     # 0x2df59
movl $0x2b, %edx
callq 0x4210
movq 0x28f3a(%rip), %rdi     # 0x3afd0
leaq 0x1b993(%rip), %rsi     # 0x2da30
movl $0x2, %edx
callq 0x4210
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
cmpq %r12, %r13
jne 0x12124
movq 0x28f15(%rip), %rdi     # 0x3afd0
leaq 0x1bec3(%rip), %rsi     # 0x2df85
movl $0x59, %edx
callq 0x4210
movq 0x28efd(%rip), %rdi     # 0x3afd0
leaq 0x1b957(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x28ee5(%rip), %rdi     # 0x3afd0
leaq 0x1beed(%rip), %rsi     # 0x2dfdf
movl $0xa, %edx
callq 0x4210
movq 0x28ecd(%rip), %rdi     # 0x3afd0
leaq 0x1b927(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq %rbx, %rdi
callq 0x10c4e
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
cmpq %r13, %r12
je 0x121b0
movq 0x28e9c(%rip), %rbx     # 0x3afd0
leaq -0x228(%rbp), %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0xb89c
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb89c
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
addq $0x10, %r12
cmpq %r13, %r12
jne 0x1213b
movq 0x28e09(%rip), %rax     # 0x3afc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x4180
leaq -0x130(%rbp), %rdi
callq 0x40a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x121fa
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::atualizar_dados_funcionario()
bool Petfera::atualizar_dados_funcionario()
{
	int id_funcionario;

	listarTodosFuncaionarios();

	cout << "ID do funcionario a ser atualizado: ";
	cin >> id_funcionario;

	for (auto &funcionario : this->funcionarioStore)
	{
		if (id_funcionario == funcionario->getId())
		{
			atualizar_funcionario(funcionario);
			break;
		}
		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 0x12048
movq 0x28698(%rip), %rdi     # 0x3afd0
leaq 0x1c378(%rip), %rsi     # 0x2ecb7
movl $0x24, %edx
callq 0x4210
movq 0x28690(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
cmpq %r12, %r15
je 0x129e0
movq 0x28663(%rip), %rbx     # 0x3afd0
leaq 0x1c322(%rip), %r14     # 0x2ec96
movl -0x2c(%rbp), %r13d
movq (%r15), %rdi
callq 0xb78c
cmpl %eax, %r13d
je 0x129a0
movl $0x20, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4210
addq $0x10, %r15
cmpq %r12, %r15
jne 0x12974
jmp 0x129e0
movq (%r15), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%r15), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x129c9
movq 0x2860d(%rip), %rcx     # 0x3afc8
cmpb $0x0, (%rcx)
je 0x129c5
incl 0x8(%rax)
jmp 0x129c9
lock
incl 0x8(%rax)
leaq -0x40(%rbp), %rsi
callq 0x1d78a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x129e0
callq 0x4eac
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 0x12a02
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarTodosAnimais()
void Petfera::listarTodosAnimais()
{

	ofstream arqCache_animais("cache_animais.dat");

	cout << "Aqui estao todo os animais na Petfera"
			 << "\n\n";

	if (animalStore.size() == 0)
	{
		cout << "Não temos nenhum animal em nosso Banco de dados, por favor, cadastre um animal"
				 << "\n"
				 << "retornando"
				 << "\n";

		inicio();
	}
	for (auto &novo : this->animalStore)
	{
		cout << (*novo) << endl;
		arqCache_animais << (*novo) << endl;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x1b5c2(%rip), %rsi     # 0x2dfea
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x41f0
movq 0x28590(%rip), %rdi     # 0x3afd0
leaq 0x1b5b5(%rip), %rsi     # 0x2dffc
movl $0x25, %edx
callq 0x4210
movq 0x28578(%rip), %rdi     # 0x3afd0
leaq 0x1afd1(%rip), %rsi     # 0x2da30
movl $0x2, %edx
callq 0x4210
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r12, %r13
jne 0x12ae4
movq 0x28554(%rip), %rdi     # 0x3afd0
leaq 0x1b59f(%rip), %rsi     # 0x2e022
movl $0x4f, %edx
callq 0x4210
movq 0x2853c(%rip), %rdi     # 0x3afd0
leaq 0x1af96(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x28524(%rip), %rdi     # 0x3afd0
leaq 0x1b52c(%rip), %rsi     # 0x2dfdf
movl $0xa, %edx
callq 0x4210
movq 0x2850c(%rip), %rdi     # 0x3afd0
leaq 0x1af66(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq %rbx, %rdi
callq 0x10c4e
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x12b70
movq 0x284dc(%rip), %rbx     # 0x3afd0
leaq -0x228(%rbp), %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x7a1f
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq (%r12), %rsi
movq %r14, %rdi
callq 0x7a1f
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
addq $0x10, %r12
cmpq %r13, %r12
jne 0x12afb
movq 0x28449(%rip), %rax     # 0x3afc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x4180
leaq -0x130(%rbp), %rdi
callq 0x40a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12bba
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarVeterinario()
std::shared_ptr<Funcionario> Petfera::pegarVeterinario()
{
	std::shared_ptr<Funcionario> novo;

	int id;
	cout << "O IBAMA nos obriga a escolher um veterinario para cuidar do animal"
			 << "\n";

	cout << "Para continuar o cadastro escolha pelo ID um dos tratadores que temos na loja"
			 << "\n";

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getClassicicacao() == Veterinario)
		{
			cout << *(funcionario) << "\n";
		}
	}

	cout << "Escolha um veterinario (Utilizando o ID por favor)"
			 << "\n";

	cin >> id;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x27890(%rip), %rdi     # 0x3afd0
leaq 0x1a60c(%rip), %rsi     # 0x2dd53
movl $0x42, %edx
callq 0x4210
movq 0x27878(%rip), %rdi     # 0x3afd0
leaq 0x1a2d2(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x27860(%rip), %rdi     # 0x3afd0
leaq 0x1a61f(%rip), %rsi     # 0x2dd96
movl $0x4d, %edx
callq 0x4210
movq 0x27848(%rip), %rdi     # 0x3afd0
leaq 0x1a2a2(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x20(%r14), %r13
movq %r14, -0x38(%rbp)
movq 0x28(%r14), %r14
cmpq %r14, %r13
je 0x137ea
movq 0x2781f(%rip), %r15     # 0x3afd0
leaq 0x1a279(%rip), %r12     # 0x2da31
movq (%r13), %rdi
callq 0xb7f2
testl %eax, %eax
jne 0x137e1
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb89c
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x137b8
movq 0x277df(%rip), %rdi     # 0x3afd0
leaq 0x1a5ec(%rip), %rsi     # 0x2dde4
movl $0x32, %edx
callq 0x4210
movq -0x38(%rbp), %r14
movq 0x277c3(%rip), %rdi     # 0x3afd0
leaq 0x1a21d(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x277bb(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
cmpq %r12, %r15
je 0x13867
leaq 0x8(%rbx), %r14
movq (%r15), %rdi
callq 0xb78c
cmpl -0x2c(%rbp), %eax
jne 0x1385e
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7c76
addq $0x10, %r15
cmpq %r12, %r15
jne 0x1383f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1388d
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13890
callq 0x4eac
jmp 0x13890
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarTratador()
std::shared_ptr<Funcionario> Petfera::pegarTratador()
{
	std::shared_ptr<Funcionario> novo;

	int id;
	cout << "O IBAMA nos obriga a escolher um tratador para cuidar do animal"
			 << "\n";

	cout << "Para continuar o cadastro escolha pelo ID um dos tratadores que temos na loja"
			 << "\n";

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getClassicicacao() == Tratador)
		{
			cout << *(funcionario) << "\n";
		}
	}

	cout << "Escolha um tratador (Utilizando o ID por favor)"
			 << "\n";

	cin >> id;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x27714(%rip), %rdi     # 0x3afd0
leaq 0x1a554(%rip), %rsi     # 0x2de17
movl $0x3f, %edx
callq 0x4210
movq 0x276fc(%rip), %rdi     # 0x3afd0
leaq 0x1a156(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x276e4(%rip), %rdi     # 0x3afd0
leaq 0x1a4a3(%rip), %rsi     # 0x2dd96
movl $0x4d, %edx
callq 0x4210
movq 0x276cc(%rip), %rdi     # 0x3afd0
leaq 0x1a126(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x20(%r14), %r13
movq %r14, -0x38(%rbp)
movq 0x28(%r14), %r14
cmpq %r14, %r13
je 0x13967
movq 0x276a3(%rip), %r15     # 0x3afd0
leaq 0x1a0fd(%rip), %r12     # 0x2da31
movq (%r13), %rdi
callq 0xb7f2
cmpl $0x1, %eax
jne 0x1395e
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb89c
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x13934
movq 0x27662(%rip), %rdi     # 0x3afd0
leaq 0x1a4e2(%rip), %rsi     # 0x2de57
movl $0x2f, %edx
callq 0x4210
movq -0x38(%rbp), %r14
movq 0x27646(%rip), %rdi     # 0x3afd0
leaq 0x1a0a0(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x2763e(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
cmpq %r12, %r15
je 0x139e4
leaq 0x8(%rbx), %r14
movq (%r15), %rdi
callq 0xb78c
cmpl -0x2c(%rbp), %eax
jne 0x139db
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7c76
addq $0x10, %r15
cmpq %r12, %r15
jne 0x139bc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a0a
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13a0d
callq 0x4eac
jmp 0x13a0d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Petfera::leString(string str_prompt)
{
	string var;
	cout << str_prompt;
	cin >> var;
	// getline(cin, var);
	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq 0x26cb6(%rip), %rdi     # 0x3afd0
callq 0x4210
movq 0x26cba(%rip), %rdi     # 0x3afe0
movq %rbx, %rsi
callq 0x4220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x14352
movq (%r15), %rsi
incq %rsi
callq 0x41d0
movq %r14, %rdi
callq 0x42f0