LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
	   << "time(s)" << endl;

	// print each line in chich the word appeared
	for (auto num : *qr.lines) {
		os << "\t(line " << num + 1 << ") "
		   << *(qr.file->begin() + num) << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2170
leaq 0x1321(%rip), %rsi      # 0x404c
movq %rax, %rdi
callq 0x2180
movq 0x20(%r14), %rcx
movq 0x28(%rcx), %rsi
movq %rax, %rdi
callq 0x2120
leaq 0x131c(%rip), %rsi      # 0x4066
movq %rax, %rdi
callq 0x2180
leaq 0x12fc(%rip), %rsi      # 0x4055
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq 0x20(%r14), %r13
movq 0x18(%r13), %r12
addq $0x8, %r13
cmpq %r13, %r12
je 0x2dd4
movq 0x20(%r12), %r15
movq %rbx, %rdi
leaq 0x12d4(%rip), %rsi      # 0x405d
callq 0x2180
leaq 0x1(%r15), %rsi
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
leaq 0x12c1(%rip), %rsi      # 0x4065
callq 0x2180
movq 0x30(%r14), %rcx
shlq $0x5, %r15
addq (%rcx), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
jmp 0x2d75
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/main.cpp
// Function: main
int main (int argc, char* argv[]) {

  if (argc < 5) {
    cout << endl << "Usage: \n ./RamMachine <inputTape.txt> <outputTape.txt> <program.ram> <Memory-size>" << endl << endl;
    return -1;
  }
  string inTape (argv[1]);
  string outTape (argv[2]);
  string fich (argv[3]);
  int size = atoi (argv[4]);

  RamMachine * myMachine = new RamMachine (inTape, outTape, fich, size);

  menu(myMachine);



  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
cmpl $0x4, %edi
jg 0x5cbb
movq 0x1b311(%rip), %rdi     # 0x20fa0
callq 0x51c0
leaq 0xf53d(%rip), %rsi      # 0x151d8
movq %rax, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x51c0
pushq $-0x1
popq %rax
jmp 0x5dac
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x5150
movq 0x10(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5150
movq 0x18(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5150
movq 0x20(%rbx), %rdi
callq 0x5530
movl %eax, %ebp
pushq $0x28
popq %rdi
callq 0x5360
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x5490
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5490
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5490
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %r8d
callq 0x12ba8
leaq 0x50(%rsp), %rdi
callq 0x51a0
leaq 0x70(%rsp), %rdi
callq 0x51a0
leaq 0x90(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x587c
leaq 0x10(%rsp), %rdi
callq 0x51a0
leaq 0x30(%rsp), %rdi
callq 0x51a0
leaq 0xb0(%rsp), %rdi
callq 0x51a0
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x51a0
jmp 0x5dca
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x51a0
jmp 0x5dd9
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x51a0
jmp 0x5deb
movq %rax, %r14
movq %rbx, %rdi
callq 0x5340
jmp 0x5e02
movq %rax, %r14
jmp 0x5e0c
movq %rax, %r14
jmp 0x5e16
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x51a0
leaq 0x30(%rsp), %rdi
callq 0x51a0
leaq 0xb0(%rsp), %rdi
callq 0x51a0
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Program::readFile (string fileName){
  ifstream file;
  string fileData = "";
  fileName_ = fileName;
  file.open (fileName.c_str());
  if (file.is_open()) {
    while (!file.eof()) {
      string temp;
      getline (file,temp);
      fileData += temp + "\n";
    }
    file.close();
  }
  else {
    cerr << "El fichero no existe" << endl;
  }
  return fileData;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x53d0
leaq 0xf1dd(%rip), %rsi      # 0x151ce
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5150
addq $0x30, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5200
movq (%r14), %rsi
leaq 0x40(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5250
leaq 0xb8(%rsp), %rdi
callq 0x50d0
testb %al, %al
je 0x609a
leaq 0x10(%rsp), %rbp
leaq 0x40(%rsp), %r14
movq %rsp, %r15
leaq 0xf18d(%rip), %r12      # 0x151cd
leaq 0x20(%rsp), %r13
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x60(%rsp,%rax)
jne 0x60b7
movq %rbp, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5090
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6e52
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5630
movq %r13, %rdi
callq 0x51a0
movq %r15, %rdi
callq 0x51a0
jmp 0x6045
movq 0x1af47(%rip), %rdi     # 0x20fe8
leaq 0xf270(%rip), %rsi      # 0x15318
callq 0x5350
movq %rax, %rdi
callq 0x51c0
jmp 0x60c1
leaq 0x40(%rsp), %rdi
callq 0x50a0
leaq 0x40(%rsp), %rdi
callq 0x50e0
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x610e
movq %rax, %r14
jmp 0x6106
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x51a0
jmp 0x60fe
jmp 0x60fb
movq %rax, %r14
movq %rsp, %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x51a0
leaq 0x40(%rsp), %rdi
callq 0x50e0
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::getTagFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Program::getTagFromString(string data) {
    string result = "noTag";
    //cout << "Analize string for tag : " << endl << data << endl;
    if (data.find(":") != string::npos) {                                    // If there is a tag
      for (int i = 0; i < data.size(); i++) {
        if (data[i] == ':'){                                              // When we detect Tag
          int it = i;                                                // we create iterator to go backwards
          string tag;
          while(data[--it] == ' ' || data[it] == '\t' || data[it] == ':');                         // until we search any character to save the tag name
          while(data[it] != ' '  &&                                          // then we continue saving characters backwards until we reach space again
                data[it] != '\t' && it >= 0) {                                          // or tabulator.
             //cout << "We push : data[" << it << "] = " << data[it] << endl;
              tag.push_back(data[it--]);
          }
          reverse(tag.rbegin(), tag.rend());
          result = tag;
        }
      }
    }
    return result;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
leaq 0xe884(%rip), %rsi      # 0x15368
leaq 0x8(%rsp), %rdx
movq %rdi, (%rsp)
callq 0x5150
leaq 0xfa0b(%rip), %rsi      # 0x16504
movq %r14, %rdi
xorl %edx, %edx
callq 0x5640
cmpq $-0x1, %rax
je 0x6bcd
pushq $-0x1
popq %rbx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movabsq $0x400000100000200, %r12 # imm = 0x400000100000200
cmpq %r15, 0x8(%r14)
jbe 0x6bcd
movq (%r14), %rax
cmpb $0x3a, (%rax,%r15)
jne 0x6bc2
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rbp
movzbl (%rax,%rbp), %ecx
cmpq $0x3a, %rcx
ja 0x6b75
btq %rcx, %r12
jae 0x6b75
decq %rbp
jmp 0x6b52
decq %rbp
movsbl %al, %esi
movq %r13, %rdi
callq 0x52f0
movq (%r14), %rax
movb (%rax,%rbp), %al
cmpb $0x20, %al
je 0x6b88
testq %rbp, %rbp
js 0x6b88
cmpb $0x9, %al
jne 0x6b67
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7099
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x5200
movq %r13, %rdi
callq 0x51a0
incq %r15
incq %rbx
jmp 0x6b22
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6be2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq (%rsp), %rdi
callq 0x51a0
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::existsTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Program::existsTag(string tag)
{
  for(int i = 0; i < tags_.size(); i++) {
    if(tags_[i]->getId() == tag) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movq %rax, %r12
movq 0x18(%r14), %rax
movq 0x20(%r14), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r12, %r13
jbe 0x6c9f
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x5490
movq %r15, %rdi
movq %rbx, %rsi
callq 0x70bd
movl %eax, %ebp
movq %r15, %rdi
callq 0x51a0
leaq 0x1(%r12), %rax
testb %bpl, %bpl
je 0x6c5d
cmpq %r12, %r13
seta %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::show()
void Program::show() {
  cout << "Tags: " << endl;
  for(int i = 0; i < tags_.size(); i++) {
    tags_[i]->show();
  }
  cout << "===============================" << endl;

  cout << "Instructions: " << endl;
  for(int i = 0; i < instructions_.size(); i++) {
    instructions_[i]->show();
  }
  cout << "===============================" << endl << endl;

  cout << "Pulse Enter para volver al menu..." << endl;
  cin.get();
  cin.get();
  system("clear");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a2de(%rip), %rdi     # 0x20fa0
leaq 0xe6f0(%rip), %rsi      # 0x153b9
callq 0x5350
movq %rax, %rdi
callq 0x51c0
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x6cfb
movq (%rax,%r14,8), %rdi
callq 0x70e0
incq %r14
jmp 0x6cd9
movq 0x1a29e(%rip), %r14     # 0x20fa0
leaq 0xe6b7(%rip), %rsi      # 0x153c0
movq %r14, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
leaq 0xe6c0(%rip), %rsi      # 0x153e0
movq %r14, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x6d54
movq (%rax,%r14,8), %rdi
callq 0x7134
incq %r14
jmp 0x6d33
movq 0x1a245(%rip), %rbx     # 0x20fa0
leaq 0xe65e(%rip), %rsi      # 0x153c0
movq %rbx, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x51c0
leaq 0xe66e(%rip), %rsi      # 0x153ef
movq %rbx, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq 0x1a238(%rip), %rbx     # 0x20fd0
movq %rbx, %rdi
callq 0x5420
movq %rbx, %rdi
callq 0x5420
leaq 0xe36e(%rip), %rdi      # 0x1511d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::getLineByTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Program::getLineByTag(string tag) {
  for (int i = 0; i < tags_.size(); i++)
    if (tags_[i]->getId() == tag)
      return tags_[i]->getLine();
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
pushq $-0x1
popq %rbx
leaq 0x8(%rsp), %r12
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x6e24
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
callq 0x5490
movq %r12, %rdi
movq %r15, %rsi
callq 0x70bd
movl %eax, %ebp
movq %r12, %rdi
callq 0x51a0
incq %r13
testb %bpl, %bpl
je 0x6ddb
movq 0x18(%r14), %rax
movq -0x8(%rax,%r13,8), %rax
movl 0x20(%rax), %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/./Instruction.h
// Function: Instruction::Instruction()
Instruction () {
    line_ = -1;
    tag_ = "";
    op_ = "";
    type_ = '\0';
    operand_ = "";
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movb %al, 0x38(%rdi)
leaq 0x50(%rdi), %r12
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movb %al, 0x60(%rdi)
orl $-0x1, (%rdi)
leaq 0xe2b7(%rip), %rsi      # 0x151ce
movq %rbx, %rdi
callq 0x5620
leaq 0xe2a8(%rip), %rsi      # 0x151ce
movq %r14, %rdi
callq 0x5620
movb $0x0, 0x48(%r15)
leaq 0xe294(%rip), %rsi      # 0x151ce
movq %r12, %rdi
callq 0x5620
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x51a0
movq %r14, %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x51a0
movq %r15, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::RamMachine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
RamMachine::RamMachine(string in, string out, string program, int size)
{
  pc_ = 0;
  inTape_ = new ITape(in);
  outTape_ = new OTape(out);
  program_ = new Program(program);
  memory_ = new Memory(size);
  error_ = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
andl $0x0, 0x20(%rdi)
pushq $0x40
popq %rdi
callq 0x5360
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x5490
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x13d28
movq %rbx, (%r14)
leaq 0x48(%rsp), %rdi
callq 0x51a0
pushq $0x40
popq %rdi
callq 0x5360
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x5490
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1406c
movq %rbx, 0x8(%r14)
leaq 0x28(%rsp), %rdi
callq 0x51a0
pushq $0x50
popq %rdi
callq 0x5360
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x5490
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e2c
movq %rbx, 0x18(%r14)
leaq 0x8(%rsp), %rdi
callq 0x51a0
pushq $0x18
popq %rdi
callq 0x5360
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
callq 0x142fc
movq %rbx, 0x10(%r14)
movb $0x0, 0x24(%r14)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12cb7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x12cb0
jmp 0x12cb7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x12cb0
jmp 0x12cb7
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x51a0
jmp 0x12cba
movq %rax, %r14
movq %rbx, %rdi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::~RamMachine()
RamMachine::~RamMachine() {
  delete memory_;
  delete inTape_;
  delete outTape_;
  delete program_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x12ce2
movq %r14, %rdi
callq 0x14332
movq %r14, %rdi
callq 0x5340
movq (%rbx), %r14
testq %r14, %r14
je 0x12cfa
movq %r14, %rdi
callq 0x13e68
movq %r14, %rdi
callq 0x5340
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x12d13
movq %r14, %rdi
callq 0x140a2
movq %r14, %rdi
callq 0x5340
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0x12d2c
movq %rbx, %rdi
callq 0x5f42
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::jumpManager(Instruction*)
void RamMachine::jumpManager (Instruction* actual) {
  pc_ = program_->getLineByTag (actual->getOperand());
  if (pc_ == -1) {
    cout << "el Tag " << actual->getOperand () << " no se encuentra en el programa.\nSaliendo al menu..." << endl;
    error_ = true;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq $0x50, %r14
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5490
movq %r15, %rdi
movq %r12, %rsi
callq 0x6dbc
movl %eax, 0x20(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x51a0
cmpl $-0x1, 0x20(%rbx)
jne 0x13949
movq 0xd6a6(%rip), %rdi      # 0x20fa0
leaq 0x2c45(%rip), %rsi      # 0x16546
callq 0x5350
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5490
movq %r15, %rdi
movq %r12, %rsi
callq 0x5310
leaq 0x2c23(%rip), %rsi      # 0x1654e
movq %rax, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
leaq 0x8(%rsp), %rdi
callq 0x51a0
movb $0x1, 0x24(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x13967
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::showActualState(Instruction*)
void RamMachine::showActualState (Instruction* actual) {
  cout << "Input tape:" << endl;
  inTape_->show();
  actual->show();
  memory_->show();
  cout << "Contenido de la cinta de salida: " ;
  outTape_->show();
  cout << endl << endl << "Pulse Enter para continuar..." << endl;
  cin.get();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0xd61a(%rip), %rbx      # 0x20fa0
leaq 0x2b6d(%rip), %rsi      # 0x164fa
movq %rbx, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq (%r14), %rdi
callq 0x1422c
movq %r15, %rdi
callq 0x7134
movq 0x10(%r14), %rdi
callq 0x14382
leaq 0x2b49(%rip), %rsi      # 0x16506
movq %rbx, %rdi
callq 0x5350
movq 0x8(%r14), %rdi
callq 0x1422c
movq %rbx, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x51c0
leaq 0x2b43(%rip), %rsi      # 0x16528
movq %rax, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq 0xd5d4(%rip), %rdi      # 0x20fd0
popq %rbx
popq %r14
popq %r15
jmp 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::saveToOutputTape()
void RamMachine::saveToOutputTape () {
  outTape_->saveToFile();
  cout << "Pulse Enter para volver al menu..." << endl;
  cin.get();
  cin.get();
  system("clear");
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rdi
callq 0x140dc
movq 0xd589(%rip), %rdi      # 0x20fa0
leaq 0x19d1(%rip), %rsi      # 0x153ef
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq 0xd59e(%rip), %rbx      # 0x20fd0
movq %rbx, %rdi
callq 0x5420
movq %rbx, %rdi
callq 0x5420
leaq 0x16d4(%rip), %rdi      # 0x1511d
popq %rbx
jmp 0x52e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/ITape.cpp
// Function: ITape::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ITape::load(string fileName) {
  inx_ = 0;
  fstream file;
  int num;
  fileName_ = fileName;
  file.open(fileName.c_str(), ios::in );

  if(file.is_open()) {
      nodes_.clear();
    while(file >> num){
      nodes_.push_back(num);
    }
    file.close();
  }
  else{
      cerr << "El fichero no existe" << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, 0x18(%rdi)
leaq 0x10(%rsp), %rdi
callq 0x5410
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5200
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5330
leaq 0x90(%rsp), %rdi
callq 0x50d0
testb %al, %al
je 0x13e12
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x13de2
movq %rax, 0x8(%rbx)
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13e2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13f0a
jmp 0x13dec
movq 0xd1cf(%rip), %rdi      # 0x20fe8
leaq 0x14f8(%rip), %rsi      # 0x15318
callq 0x5350
movq %rax, %rdi
callq 0x51c0
jmp 0x13e39
leaq 0x10(%rsp), %rdi
callq 0x5070
leaq 0x10(%rsp), %rdi
callq 0x50b0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13e52
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/ITape.cpp
// Function: ITape::read()
int ITape::read()
{
  if (inx_ < nodes_.size())
      return nodes_[inx_++];
  else
      return 0;
}

// Assembly:
movl 0x18(%rdi), %ecx
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
jbe 0x13ea3
leal 0x1(%rcx), %eax
movl %eax, 0x18(%rdi)
movl (%rdx,%rcx,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/OTape.cpp
// Function: OTape::saveToFile()
void OTape::saveToFile() {
  ofstream outFile;
  outFile.open(fileName_.c_str());
  char option;
  cout << "¿Desea ver el contenido que se va a volcar en la cinta de salida? (s/n): " ;
  cin >> option;
  if (option == 's')
     show();

  for(int i = 0; i < nodes_.size(); i++) {
    outFile << nodes_[i] << " ";
  }
  outFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5580
movq 0x20(%rbx), %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x5060
movq 0xce90(%rip), %rdi      # 0x20fa0
leaq 0x2471(%rip), %rsi      # 0x16588
callq 0x5350
movq 0xcead(%rip), %rdi      # 0x20fd0
leaq 0x7(%rsp), %rsi
callq 0x5480
cmpb $0x73, 0x7(%rsp)
jne 0x1413c
movq %rbx, %rdi
callq 0x1422c
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
leaq 0x24a0(%rip), %r15      # 0x165eb
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1417a
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x55a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5350
incq %r12
jmp 0x1414b
leaq 0x8(%rsp), %rdi
callq 0x54c0
leaq 0x8(%rsp), %rdi
callq 0x5500
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x141a1
jmp 0x141a1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5500
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Cicko[P]Ram-Machine/Tape.cpp
// Function: Tape::show()
void Tape::show()
{
  cout << "[" ;
  for (int i = 0; i < nodes_.size(); i++)
  {
    cout << " " << nodes_[i];
    if (i < nodes_.size()-1) {
      cout << ",";
    }
  }
  cout << "]" << endl;
  cout << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xcd61(%rip), %r14      # 0x20fa0
leaq 0x11e3(%rip), %rsi      # 0x15429
movq %r14, %rdi
callq 0x5350
xorl %r13d, %r13d
leaq 0x2393(%rip), %r15      # 0x165eb
leaq 0x2374(%rip), %r12      # 0x165d3
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r13, %rax
jbe 0x142ac
movq %r14, %rdi
movq %r15, %rsi
callq 0x5350
movq (%rbx), %rcx
movl (%rcx,%r13,4), %esi
movq %rax, %rdi
callq 0x55a0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
decq %rax
cmpq %r13, %rax
jbe 0x142a7
movq %r14, %rdi
movq %r12, %rsi
callq 0x5350
incq %r13
jmp 0x1425f
movq 0xcced(%rip), %rbx      # 0x20fa0
leaq 0x10b8(%rip), %rsi      # 0x15372
movq %rbx, %rdi
callq 0x5350
movq %rax, %rdi
callq 0x51c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/rossa.h
// Function: printc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, TextColor const&)
inline void printc(const std::string &s, const TextColor &color)
{
#ifndef _WIN32
	std::cout << colorASCII(color) << s << colorASCII(0);
#else
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hConsole, color);
	std::cout << s;
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movl (%rsi), %esi
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x1cac0
leaq 0x59a04(%rip), %rsi     # 0x76279
leaq 0x68(%rsp), %rdi
movq %r14, %rdx
callq 0x1ca9c
leaq 0x59add(%rip), %rdx     # 0x76366
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1ca7d
movq 0x996e6(%rip), %rdi     # 0xb5f88
leaq 0x88(%rsp), %rsi
callq 0x10370
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10370
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1cac0
leaq 0x599a9(%rip), %rsi     # 0x76279
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1ca9c
leaq 0x59a80(%rip), %rdx     # 0x76366
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ca7d
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x10370
leaq 0x48(%rsp), %rdi
callq 0x101d0
leaq 0x28(%rsp), %rdi
callq 0x101d0
leaq 0x8(%rsp), %rdi
callq 0x101d0
leaq 0x88(%rsp), %rdi
callq 0x101d0
leaq 0x68(%rsp), %rdi
callq 0x101d0
leaq 0xa8(%rsp), %rdi
callq 0x101d0
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x101d0
jmp 0x1c961
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x101d0
jmp 0x1c970
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
jmp 0x1c98b
jmp 0x1c988
movq %rax, %rbx
jmp 0x1c998
movq %rax, %rbx
jmp 0x1c9a2
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x101d0
leaq 0x68(%rsp), %rdi
callq 0x101d0
leaq 0xa8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parser/parser.cpp
// Function: parser_t::compileCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::filesystem::__cxx11::path const&)
const ptr_node_t parser_t::compileCode(const std::string &code, const std::filesystem::path &currentFile)
{
	auto tokens = lexString(code, currentFile);
	node_parser_t testnp(tokens, currentFile);
	auto n = testnp.parse(&this->scopes, &this->consts);
	// fold twice (temporary) to refold constants
	return n->fold(this->consts)->fold(this->consts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x218e6
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x22dd4
leaq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
callq 0x2e62e
movq 0x18(%rsp), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r14, %rdx
callq *0x18(%rax)
leaq 0x10(%rsp), %rdi
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x1d786
leaq 0x40(%rsp), %rdi
callq 0x1f11e
leaq 0x28(%rsp), %rdi
callq 0x1f142
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1d786
jmp 0x1e3ce
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1d786
jmp 0x1e3dd
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1f11e
jmp 0x1e3ec
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1f142
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parser/parser.cpp
// Function: parser_t::runCode(std::shared_ptr<Node> const&, bool const&)
const symbol_t parser_t::runCode(const ptr_node_t &entry, const bool &tree)
{
	if (tree)
	{
		entry->printTree("", true);
		for (auto &c : consts)
		{
			int i = 0;
			for (auto &p : c.first)
			{
				if (i++ > 0)
				{
					printc(".", CYAN_TEXT);
				}
				printc(ROSSA_DEHASH(p), CYAN_TEXT);
			}
			std::cout << " = ";
			printc(c.second.toCodeString(), CYAN_TEXT);
			std::cout << "\n";
		}
	}

	auto g = node_parser_t::genParser(entry);

	trace_t stack_trace;
	return g->evaluate(&main, stack_trace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
cmpb $0x1, (%rcx)
jne 0x1e55d
movq 0x28(%rsp), %rax
movq (%rax), %rbx
leaq 0x57d78(%rip), %rsi     # 0x761ae
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1c814
movq (%rbx), %rax
leaq 0x68(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x68(%rsp), %rdi
callq 0x101d0
movq 0x20(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r15
leaq 0x98486(%rip), %r14     # 0xb6908
cmpq 0x58(%rsp), %rbx
je 0x1e55d
movq (%rbx), %r12
movq %rbx, 0x60(%rsp)
movq 0x8(%rbx), %r13
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x1e503
subl $0x1, %ebx
jb 0x1e4d4
movq %rbp, %rdi
leaq 0x57ee7(%rip), %rsi     # 0x76396
leaq 0xf(%rsp), %rdx
callq 0x1c814
movl $0x24, 0x10(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1c84f
movq %rbp, %rdi
callq 0x101d0
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1f164
movl $0x24, 0x10(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1c84f
movq %rbp, %rdi
callq 0x101d0
addq $0x8, %r12
jmp 0x1e49b
movq 0x97a7e(%rip), %r12     # 0xb5f88
movq %r12, %rdi
leaq 0x57e65(%rip), %rsi     # 0x76379
callq 0x103b0
movq 0x60(%rsp), %rbx
leaq 0x18(%rbx), %rsi
movq %rbp, %rdi
callq 0x3aaf4
movl $0x24, 0x10(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1c84f
movq %rbp, %rdi
callq 0x101d0
movq %r12, %rdi
leaq 0x595ce(%rip), %rsi     # 0x77b1d
callq 0x103b0
addq $0x28, %rbx
jmp 0x1e482
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x2e660
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
andq $0x0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq (%rbx), %rsi
movq 0x20(%rsp), %rdx
addq $0x30, %rdx
movq (%rsi), %rax
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq *(%rax)
leaq 0x30(%rsp), %rdi
callq 0x1cb1a
leaq 0x18(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x1e5f7
jmp 0x1e5e8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1cb1a
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x1e5fc
jmp 0x1e5ef
movq %rax, %rbx
jmp 0x1e5fc
jmp 0x1e5ef
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parser/../rossa.h
// Function: Hash::hashValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline const hash_ull hashValue(const std::string &key)
	{
		if (std::find(variable_hash.begin(), variable_hash.end(), key) != variable_hash.end())
			return std::distance(variable_hash.begin(), std::find(variable_hash.begin(), variable_hash.end(), key));
		variable_hash.push_back(key);
		return variable_hash.size() - 1;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x1f34e
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
je 0x1efe9
movq (%rbx), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1f34e
subq %rbx, %rax
sarq $0x5, %rax
jmp 0x1f002
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f322
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/function/function.cpp
// Function: function_evaluate_vargs(std::shared_ptr<function_t> const&, std::vector<symbol_t, std::allocator<symbol_t>> const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t function_evaluate_vargs(const ptr_function_t &function, const std::vector<symbol_t> &paramValues, const token_t *token, trace_t &stack_trace)
{
	object_t p(function->parent, object_type_enum::OBJECT_WEAK);
	const object_t newScope(&p, 0);

	newScope.createVariable(parser_t::HASH_VAR_ARGS, symbol_t::Array(paramValues), token);

	for (const std::pair<const hash_ull, const symbol_t> &e : function->captures)
	{
		newScope.createVariable(e.first, e.second, token);
	}

	symbol_t temp = function->body->evaluate(&newScope, stack_trace);

	if (temp.getSymbolType() == symbol_t::type_t::ID_REFER)
	{
		temp.setSymbolType(symbol_t::type_t::ID_CASUAL);

		stack_trace.pop_back();
		return temp;
	}

	const symbol_t ret = symbol_t();
	ret.set(&temp, token, stack_trace);

	stack_trace.pop_back();
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq (%rsi), %rax
movq 0x18(%rax), %rsi
leaq 0x18(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x3618c
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x36228
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3909c
leaq 0x94136(%rip), %rsi     # 0xb6a08
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rcx
callq 0x366fc
leaq 0x8(%rsp), %rdi
callq 0x39102
movq (%r12), %rbx
movq 0x60(%rbx), %rbp
addq $0x50, %rbx
leaq 0x18(%rsp), %r13
cmpq %rbx, %rbp
je 0x22924
leaq 0x20(%rbp), %rsi
leaq 0x28(%rbp), %rdx
movq %r13, %rdi
movq %r15, %rcx
callq 0x366fc
movq %rbp, %rdi
callq 0x104a0
movq %rax, %rbp
jmp 0x228ff
movq (%r12), %rax
movq 0x38(%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq 0x28(%rsp), %r12
movq %r12, %rcx
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x39682
movq %r14, %rbx
cmpl $0x4, %eax
jne 0x22981
leaq 0x34(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x39686
movq %r12, %rdi
callq 0x22ac6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x390f0
jmp 0x229a4
movq %rbx, %rdi
callq 0x38d00
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3927a
movq %r12, %rdi
callq 0x22ac6
leaq 0x8(%rsp), %rdi
callq 0x39102
leaq 0x18(%rsp), %rdi
callq 0x363f2
leaq 0x38(%rsp), %rdi
callq 0x363f2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x39102
jmp 0x229f1
jmp 0x229ee
jmp 0x229fd
jmp 0x229ee
jmp 0x229fd
movq %rax, %r14
jmp 0x22a0a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x39102
jmp 0x22a00
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x363f2
leaq 0x38(%rsp), %rdi
callq 0x363f2
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseUnOpNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseUnOpNode(std::vector<node_scope_t> *scopes)
{
	std::string opStr = currentToken.valueString;
	auto marker = currentToken;
	nextToken();
	if (UNARY_OPERATORS.find(opStr) != UNARY_OPERATORS.end())
	{
		if (auto a = parseUnitNode(scopes))
			return std::make_shared<UnOpNode>(*scopes, opStr, a, marker);
		return logErrorN(_FAILURE_PARSE_CODE_, currentToken);
	}
	else
	{
		return logErrorN(_NOT_UNARY_OP_, marker);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsi), %r15
addq $0xb0, %rsi
leaq 0x38(%rsp), %rdi
callq 0x10550
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x1f71a
movq %r14, %rdi
callq 0x22e24
leaq 0x8c89a(%rip), %rdi     # 0xb6b38
leaq 0x38(%rsp), %rsi
callq 0x220d0
leaq 0x8c891(%rip), %rcx     # 0xb6b40
cmpq %rcx, %rax
je 0x2a331
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2780a
cmpq $0x0, (%rsp)
je 0x2a355
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rsp, %rcx
leaq 0x58(%rsp), %r8
movq %r12, %rsi
callq 0x2ef0b
leaq 0x28(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x58(%rsp), %rdi
callq 0x1df38
leaq 0x38(%rsp), %rdi
callq 0x101d0
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4c693(%rip), %rsi     # 0x769cb
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1c814
movq %rsp, %rdx
leaq 0x58(%rsp), %rcx
movq %r14, %rsi
callq 0x25932
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x4c5d4(%rip), %rsi     # 0x7693a
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1c814
movq %rsp, %rdx
movq %r14, %rsi
movq %r15, %rcx
callq 0x25932
jmp 0x2a385
jmp 0x2a3a7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x101d0
jmp 0x2a3aa
jmp 0x2a3a7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x2a3aa
jmp 0x2a3a7
jmp 0x2a3a7
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1df38
leaq 0x38(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
movq %rax, %rbx
jmp 0x2a3b4
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseBIDNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseBIDNode(std::vector<node_scope_t> *scopes)
{
	if (currentToken.type == TOK_IDF)
	{
		return parseIDNode(scopes);
	}
	auto n = std::make_shared<BIDNode>(*scopes, currentToken.valueString, currentToken);
	nextToken();
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x2, 0xd0(%rsi)
jne 0x23259
movq %rbx, %rdi
movq %r14, %rsi
callq 0x231ae
jmp 0x23294
leaq 0x58(%r14), %rcx
leaq 0xb0(%r14), %rax
movq %rsp, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2e7ed
movq %r14, %rdi
callq 0x22e24
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseEntryNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseEntryNode(std::vector<node_scope_t> *scopes)
{
	std::vector<ptr_node_t> v;
	while (currentToken.type != NULL_TOK)
		v.push_back(parseExprNode(scopes));
	return std::make_shared<VectorNode>(*scopes, v, false, currentToken);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
andq $0x0, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %rbp
cmpl $0x0, 0xd0(%r14)
je 0x23314
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x23390
movq %r13, %rdi
movq %rbp, %rsi
callq 0x30406
movq %r12, %rdi
callq 0x1d786
jmp 0x232e7
addq $0x58, %r14
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
movq %r14, %r8
callq 0x2e811
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x2e838
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2336d
movq %rax, %rbx
jmp 0x2337d
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x2e838
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseTrailingNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&, bool const&)
ptr_node_t node_parser_t::parseTrailingNode(std::vector<node_scope_t> *scopes, const ptr_node_t &ret, const bool &allowInner)
{
	if (currentToken.type == NULL_TOK)
		return ret;

	switch (currentToken.type)
	{
	case TOK_INNER:
		if (allowInner)
			return parseInsNode(scopes, ret);
		else
			return ret;
	case '(':
		return parseCallNode(scopes, ret);
	case '[':
		return parseIndexNode(scopes, ret);
	default:
		return ret;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xd0(%rsi), %eax
cmpl $-0x27, %eax
je 0x24b39
cmpl $0x5b, %eax
je 0x24b25
cmpl $0x28, %eax
je 0x24b2f
testl %eax, %eax
jmp 0x24b49
movq %rbx, %rdi
callq 0x252a2
jmp 0x24b54
movq %rbx, %rdi
callq 0x24c4a
jmp 0x24b54
cmpb $0x1, (%r8)
jne 0x24b49
movq %rbx, %rdi
callq 0x24b5a
jmp 0x24b54
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2f676
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseInsNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&)
ptr_node_t node_parser_t::parseInsNode(std::vector<node_scope_t> *scopes, const ptr_node_t &ret)
{
	auto curr = ret;
	while (currentToken.type == TOK_INNER)
	{
		nextToken();
		curr = std::make_shared<InsNode>(*scopes, curr, parseBIDNode(scopes), currentToken);
	}

	return parseTrailingNode(scopes, curr, false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x2f676
leaq 0x58(%r15), %rbp
leaq 0x18(%rsp), %r13
leaq 0x28(%rsp), %rbx
cmpl $-0x27, 0xd0(%r15)
jne 0x24be5
movq %r15, %rdi
callq 0x22e24
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x23236
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x2f089
movq %r12, %rdi
movq %rbx, %rsi
callq 0x34334
leaq 0x30(%rsp), %rdi
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x1d786
jmp 0x24b90
leaq 0x28(%rsp), %r8
movb $0x0, (%r8)
leaq 0x8(%rsp), %rcx
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24b08
leaq 0x10(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24c34
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1d786
jmp 0x24c37
jmp 0x24c34
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseIndexNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&)
ptr_node_t node_parser_t::parseIndexNode(std::vector<node_scope_t> *scopes, const ptr_node_t &a)
{
	auto marker = tokens.at(index - 2);
	nextToken();
	if (auto b = parseEquNode(scopes))
	{
		if (currentToken.type != ']')
			return logErrorN(util::format(_EXPECTED_ERROR_, {"]"}), currentToken);
		nextToken();
		auto ret = std::make_shared<BinOpNode>(*scopes, "[]", a, b, marker);
		return parseTrailingNode(scopes, ret, true);
	}
	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %rdi
movl 0x50(%rsi), %esi
addl $-0x2, %esi
callq 0x2e6c6
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
callq 0x1f71a
movq %rbx, %rdi
callq 0x22e24
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x25798
cmpq $0x0, 0x10(%rsp)
je 0x25384
cmpl $0x5d, 0xd0(%rbx)
jne 0x253b4
movq %rbx, %rdi
callq 0x22e24
leaq 0x50d05(%rip), %rdx     # 0x76020
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %r8
leaq 0x98(%rsp), %r9
movq %r15, %rsi
movq %r12, %rcx
callq 0x2ede4
leaq 0x40(%rsp), %r12
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x32ebe
leaq 0x60(%rsp), %r8
movb $0x1, (%r8)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x24b08
leaq 0x48(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x25395
leaq 0x18(%rsp), %rdi
callq 0x1d786
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x98(%rsp), %rdi
callq 0x1df38
movq %r14, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x514e9(%rip), %rsi     # 0x768a4
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1c814
leaq 0x50c50(%rip), %rsi     # 0x76021
leaq 0x60(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1c814
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0x1f298
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x3f724
leaq 0x58(%rbx), %rcx
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x25932
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x101d0
jmp 0x25434
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1cea0
jmp 0x25446
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x101d0
jmp 0x25455
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x101d0
jmp 0x25481
jmp 0x2547e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
jmp 0x25481
jmp 0x2547e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x25492
jmp 0x2548f
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x1df38
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseEquNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseEquNode(std::vector<node_scope_t> *scopes)
{
	if (currentToken.type == NULL_TOK)
		return logErrorN(_UNEXPECTED_TERMINATION_, currentToken);

	if (auto ret = parseUnitNode(scopes))
	{
		if (currentToken.type != NULL_TOK)
		{
			switch (currentToken.type)
			{
			case TOK_UNTILT:
				return parseUntilNode(scopes, ret, true);
			case TOK_UNTILF:
				return parseUntilNode(scopes, ret, false);
			case TOK_OPR:
				ret = parseBinOpNode(scopes, ret);
				break;
			default:
				break;
			}
			if (currentToken.type == '?')
				return parseThenNode(scopes, ret);
		}

		return ret;
	}

	return logErrorN(_FAILURE_PARSE_CODE_, currentToken);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
leaq 0x58(%rsi), %r12
cmpl $0x0, 0xd0(%rsi)
je 0x258b2
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2780a
movq (%r13), %rcx
testq %rcx, %rcx
je 0x258d4
movl 0xd0(%r14), %eax
cmpl $-0x38, %eax
je 0x25860
testl %eax, %eax
je 0x25880
cmpl $-0x4, %eax
je 0x25817
cmpl $-0x37, %eax
jne 0x25848
leaq 0x20(%rsp), %r8
movb $0x1, (%r8)
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2885e
jmp 0x25897
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x28a08
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x30b82
leaq 0x28(%rsp), %rdi
callq 0x1d786
movl 0xd0(%r14), %eax
cmpl $0x3f, %eax
jne 0x2587c
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2ba40
jmp 0x25897
leaq 0x20(%rsp), %r8
movb $0x0, (%r8)
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2885e
jmp 0x25897
movq (%rsp), %rcx
movq %rcx, (%rbx)
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x510de(%rip), %rsi     # 0x76997
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1c814
movq %rsp, %rdx
movq %r14, %rsi
movq %r12, %rcx
callq 0x25932
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x51055(%rip), %rsi     # 0x7693a
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1c814
movq %rsp, %rdx
movq %r14, %rsi
movq %r12, %rcx
callq 0x25932
jmp 0x25906
jmp 0x25906
jmp 0x25906
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x25929
jmp 0x25919
jmp 0x25926
movq %rax, %rbx
movq %rsp, %rdi
callq 0x101d0
jmp 0x25929
movq %rax, %rbx
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::logErrorN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, token_t const&)
ptr_node_t node_parser_t::logErrorN(const std::string &s, const token_t &t)
{
	trace_t stack_trace;
	if (t.type == NULL_TOK)
		throw rossa_error_t(s, tokens.at(index - 1), stack_trace);
	else
		throw rossa_error_t(s, t, stack_trace);
	return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movl 0x78(%rcx), %ebp
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
testl %ebp, %ebp
jne 0x2598d
movl 0x50(%r15), %esi
addq $0x10, %r15
decl %esi
movq %r15, %rdi
callq 0x2e6c6
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3ebb8
jmp 0x2599e
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3ebb8
leaq 0x8c2fb(%rip), %rsi     # 0xb1ca0
leaq 0x9ac6(%rip), %rdx      # 0x2f472
movq %rbx, %rdi
callq 0x106c0
jmp 0x259bb
movq %rax, %r14
jmp 0x259c6
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %rsp, %rdi
callq 0x1cb1a
movq %r14, %rdi
callq 0x106f0