LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElifStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

    if (elifStmt) {
      elifStmt->generate(level);
    } else if (elseStmt) { // huhu
      elseStmt->generate(level);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq 0x11e9a(%rip), %rdi     # 0x1efc0
leaq 0x93d0(%rip), %rsi      # 0x164fd
callq 0x5210
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x11e79(%rip), %rdi     # 0x1efc0
leaq 0x96b3(%rip), %rsi      # 0x16801
callq 0x5210
movq %rax, %rdi
movq 0x11e43(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbeb0
movq 0x11e38(%rip), %rdi     # 0x1efc0
leaq 0x936c(%rip), %rsi      # 0x164fb
callq 0x5210
movq %rax, %rdi
movq 0x11e02(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd1c0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0xd1dd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xd1db
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0xd1dd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElseStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq 0x11daa(%rip), %rdi     # 0x1efc0
leaq 0x92ea(%rip), %rsi      # 0x16507
callq 0x5210
movq %rax, %rdi
movq 0x11d74(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbeb0
movq 0x11d69(%rip), %rdi     # 0x1efc0
leaq 0x929d(%rip), %rsi      # 0x164fb
callq 0x5210
movq %rax, %rdi
movq 0x11d33(%rip), %rsi     # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NArgs::generate()
virtual void generate() {
    cout << get_type()->cpp_type_string() << " " << id->name;

    if (next) {
      cout << ',';
      next->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq *%rax
movq -0x48(%rbp), %rsi
movq 0x11956(%rip), %rdi     # 0x1efc0
callq 0x51f0
movq %rax, -0x40(%rbp)
jmp 0xd675
movq -0x40(%rbp), %rdi
leaq 0x8e1f(%rip), %rsi      # 0x1649f
callq 0x5210
movq %rax, -0x58(%rbp)
jmp 0xd68b
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x10, %rsi
callq 0x51f0
jmp 0xd6a2
leaq -0x28(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd6ee
movq 0x11903(%rip), %rdi     # 0x1efc0
movl $0x2c, %esi
callq 0x5280
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xd6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5190
jmp 0xd6f4
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5400
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NString::generate_itr_header(NIdentifier*)
virtual void generate_itr_header(NIdentifier *id) {
    cout << "for (std::string " << id->name << " : ";
    cout << "javelin::string_itr(";
    generate();
    cout << ")) {" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x115b1(%rip), %rdi     # 0x1efc0
leaq 0x8dbf(%rip), %rsi      # 0x167d5
callq 0x5210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, %rdi
leaq 0x8db2(%rip), %rsi      # 0x167e7
callq 0x5210
movq 0x1157f(%rip), %rdi     # 0x1efc0
leaq 0x8da3(%rip), %rsi      # 0x167eb
callq 0x5210
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x11562(%rip), %rdi     # 0x1efc0
leaq 0x8d9b(%rip), %rsi      # 0x16800
callq 0x5210
movq %rax, %rdi
movq 0x1152c(%rip), %rsi     # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::addDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Definition*)
void Scope::addDefinition(string name, Definition *definition) {
  if (table.find(name) != table.end()) {
    throw std::runtime_error("Definition '" + name +
                             "' previously declared as a " +
                             (table[name]->isFunction() ? "fun" : "var"));
  }
  table[name] = definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x8, %rdi
callq 0xed30
movq -0xa0(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0xed60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xed00
testb $0x1, %al
jne 0xdf90
jmp 0xe116
movb $0x1, -0x95(%rbp)
movl $0x10, %edi
callq 0x5130
movq -0xa8(%rbp), %rdx
movq %rax, -0xb0(%rbp)
leaq 0x8a6b(%rip), %rsi      # 0x16a21
leaq -0x88(%rbp), %rdi
callq 0xed90
jmp 0xdfc4
leaq 0x8a63(%rip), %rdx      # 0x16a2e
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xd590
jmp 0xdfdd
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0xeea0
movq %rax, -0xb8(%rbp)
jmp 0xdffd
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %al, -0xb9(%rbp)
jmp 0xe017
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0xe023
jmp 0xe033
leaq 0x8a20(%rip), %rax      # 0x16a4a
movq %rax, -0xc8(%rbp)
jmp 0xe043
leaq 0x8a14(%rip), %rax      # 0x16a4e
movq %rax, -0xc8(%rbp)
jmp 0xe043
movq -0xc8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xd590
jmp 0xe059
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5390
jmp 0xe06b
movq -0xb0(%rbp), %rdi
movb $0x0, -0x95(%rbp)
movq 0x10f68(%rip), %rsi     # 0x1efe8
movq 0x10f31(%rip), %rdx     # 0x1efb8
callq 0x53d0
jmp 0xe157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0xe0fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0xe0f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0xe0e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5190
leaq -0x68(%rbp), %rdi
callq 0x5190
leaq -0x88(%rbp), %rdi
callq 0x5190
testb $0x1, -0x95(%rbp)
jne 0xe108
jmp 0xe114
movq -0xb0(%rbp), %rdi
callq 0x51b0
jmp 0xe14b
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x8, %rdi
callq 0xeea0
movq -0xd0(%rbp), %rcx
movq %rcx, (%rax)
addq $0xd0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x5400
nopw (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::findDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Definition * Scope::findDefinition(string name) {
  auto itr = table.find(name);
  if (itr != table.end()) {
    return (*itr).second;
  } else if (this->next != NULL) {
    return this->next->findDefinition(name);
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
callq 0xed30
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0xed60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xed00
testb $0x1, %al
jne 0xe1b0
jmp 0xe1c3
leaq -0x20(%rbp), %rdi
callq 0xeed0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe233
movq -0x60(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xe22b
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5100
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x70(%rbp)
jmp 0xe201
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5190
jmp 0xe233
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5190
jmp 0xe240
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5400
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: FunctionDefinition::argsMatch(NExpressionArgs*)
bool FunctionDefinition::argsMatch(NExpressionArgs *args) {
  NExpressionArgs *itr1 = args;
  NArgs *itr2 = stmt->args;

  for (; itr1 && itr2; itr1 = itr1->next, itr2 = itr2->next) {
    Type *itr1Type = itr1->expr->get_type();
    Type *itr2Type = itr2->get_type();
    if (itr1Type->cpp_type_string() != itr2Type->cpp_type_string()) {
      return false;
    }
  }
  return itr1 == NULL && itr2 == NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x85(%rbp)
je 0xe298
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0xe2a7
jmp 0xe35c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
callq *%rax
jmp 0xe2ec
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xcbe0
movb %al, -0x86(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5190
leaq -0x58(%rbp), %rdi
callq 0x5190
movb -0x86(%rbp), %al
testb $0x1, %al
jne 0xe31d
jmp 0xe33d
movb $0x0, -0x1(%rbp)
jmp 0xe384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5190
jmp 0xe392
jmp 0xe33f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xe27b
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x87(%rbp)
jne 0xe379
cmpq $0x0, -0x28(%rbp)
sete %al
movb %al, -0x87(%rbp)
movb -0x87(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x5400
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: FunctionScope::FunctionScope(Scope*, NFunctionDeclStatement*)
FunctionScope::FunctionScope(Scope *next, NFunctionDeclStatement *stmt)
    : Scope(next) {
  addStandardDefinitions();

  addDefinition(stmt->id->name, new FunctionDefinition(stmt));

  NArgs *args = stmt->args;
  // Declare the args as local variables
  for (; args != NULL; args = args->next) {
    addDefinition(args->id->name, new ArgumentDefinition(args));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb1a0
movq -0x78(%rbp), %rdi
leaq 0xfc05(%rip), %rax      # 0x1e6c8
movq %rax, (%rdi)
callq 0xe4c0
jmp 0xeacd
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5100
jmp 0xeae4
movl $0x10, %edi
callq 0x5220
movq %rax, -0x80(%rbp)
jmp 0xeaf4
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf160
jmp 0xeb03
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xdf30
jmp 0xeb16
leaq -0x48(%rbp), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xec0c
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x10, %rsi
leaq -0x70(%rbp), %rdi
callq 0x5100
jmp 0xeb4d
movl $0x20, %edi
callq 0x5220
movq %rax, -0x88(%rbp)
jmp 0xeb60
movq -0x88(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xe420
jmp 0xeb72
movq -0x88(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xdf30
jmp 0xeb88
leaq -0x70(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xeb2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xec15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xebd0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5200
leaq -0x48(%rbp), %rdi
callq 0x5190
jmp 0xec15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xec01
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5200
leaq -0x70(%rbp), %rdi
callq 0x5190
jmp 0xec15
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xf1a0
movq -0x20(%rbp), %rdi
callq 0x5400
nopw (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: FunctionScope::findDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Definition * FunctionScope::findDefinition(string name) {
  //return Scope::findDefinition(name);
  auto itr = table.find(name);
  if (itr != table.end()) {
    return (*itr).second;
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0xed30
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0xed60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xed00
testb $0x1, %al
jne 0xec79
jmp 0xec8c
leaq -0x20(%rbp), %rdi
callq 0xeed0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xec94
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NExpressionArgs::generate()
void generate() {
    expr->generate();
    if (next) {
      cout << ',';
      next->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xef46
movq 0x10091(%rip), %rdi     # 0x1efc0
movl $0x2c, %esi
callq 0x5280
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xef00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: PrintDefinition::argsMatch(NExpressionArgs*)
virtual bool argsMatch(NExpressionArgs *args) {
    for (; args != NULL; args = args->next) {
      std::string type = args->expr->get_type()->cpp_type_string();
      if (type != "std::string" && type != "int") {
        return false;
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf3fb
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq *%rax
movq -0x58(%rbp), %rdi
leaq 0x71ce(%rip), %rsi      # 0x16546
callq 0xf4c0
movb %al, -0x49(%rbp)
jmp 0xf382
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xf38b
jmp 0xf3cd
leaq 0x76c2(%rip), %rsi      # 0x16a54
leaq -0x38(%rbp), %rdi
callq 0xf4c0
movb %al, -0x59(%rbp)
jmp 0xf3a0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xf3a9
jmp 0xf3cd
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xf3d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
jmp 0xf40a
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0xf3e8
jmp 0xf3e6
jmp 0xf3ff
jmp 0xf3ea
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf340
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: PrintDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    cout << "std::cout";
    for (; args != NULL; args = args->next) {
      cout << " << ";
      args->expr->generate();
      // As per python, place spaces between the outputs
      if (args->next) {
        cout << " << ' '";
      }
    }
    cout << " << std::endl";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xfb89(%rip), %rdi      # 0x1efc0
leaq 0x7629(%rip), %rsi      # 0x16a67
callq 0x5210
cmpq $0x0, -0x10(%rbp)
je 0xf498
movq 0xfb6f(%rip), %rdi      # 0x1efc0
leaq 0x7619(%rip), %rsi      # 0x16a71
callq 0x5210
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf488
movq 0xfb44(%rip), %rdi      # 0x1efc0
leaq 0x75f3(%rip), %rsi      # 0x16a76
callq 0x5210
jmp 0xf48a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf443
movq 0xfb21(%rip), %rdi      # 0x1efc0
leaq 0x75d8(%rip), %rsi      # 0x16a7e
callq 0x5210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: StrCastDefinition::argsMatch(NExpressionArgs*)
virtual bool argsMatch(NExpressionArgs *args) {
    // We only expect one argument for a string cast
    if (args == NULL || args->next != NULL) return false;

    std::string type = args->expr->get_type()->cpp_type_string();
    return type == "int" || type == "std::string";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf652
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf658
movb $0x0, -0x1(%rbp)
jmp 0xf6b0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rdi
leaq 0x73d9(%rip), %rsi      # 0x16a54
callq 0xb630
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0xf69f
leaq -0x38(%rbp), %rdi
leaq 0x6eaf(%rip), %rsi      # 0x16546
callq 0xb630
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: StrCastDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    std::string type = args->expr->get_type()->cpp_type_string();
    if (type == "std::string") {
      cout << "std::string(";
    } else if (type == "int") {
      cout << "std::to_string(";
    }
    args->expr->generate();
    cout << ')';
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
leaq -0x30(%rbp), %rdi
leaq 0x6e53(%rip), %rsi      # 0x16546
callq 0xb630
testb $0x1, %al
jne 0xf6fe
jmp 0xf72c
movq 0xf8bb(%rip), %rdi      # 0x1efc0
leaq 0x7386(%rip), %rsi      # 0x16a92
callq 0x5210
jmp 0xf713
jmp 0xf75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5190
jmp 0xf78f
leaq -0x30(%rbp), %rdi
leaq 0x731d(%rip), %rsi      # 0x16a54
callq 0xb630
testb $0x1, %al
jne 0xf742
jmp 0xf759
movq 0xf877(%rip), %rdi      # 0x1efc0
leaq 0x734f(%rip), %rsi      # 0x16a9f
callq 0x5210
jmp 0xf757
jmp 0xf759
jmp 0xf75b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xf76d
movq 0xf84c(%rip), %rdi      # 0x1efc0
movl $0x29, %esi
callq 0x5280
jmp 0xf780
leaq -0x30(%rbp), %rdi
callq 0x5190
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5400
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: IntCastDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    std::string type = args->expr->get_type()->cpp_type_string();
    if (type == "std::string") {
      cout << "std::stoi(";
      args->expr->generate();
      cout << ')';
    } else if (type == "int") {
      args->expr->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
leaq -0x30(%rbp), %rdi
leaq 0x6c23(%rip), %rsi      # 0x16546
callq 0xb630
testb $0x1, %al
jne 0xf92e
jmp 0xf981
movq 0xf68b(%rip), %rdi      # 0x1efc0
leaq 0x7173(%rip), %rsi      # 0x16aaf
callq 0x5210
jmp 0xf943
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xf955
movq 0xf664(%rip), %rdi      # 0x1efc0
movl $0x29, %esi
callq 0x5280
jmp 0xf968
jmp 0xf9ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5190
jmp 0xf9bc
leaq -0x30(%rbp), %rdi
leaq 0x70c8(%rip), %rsi      # 0x16a54
callq 0xb630
testb $0x1, %al
jne 0xf997
jmp 0xf9ab
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xf9a9
jmp 0xf9ab
jmp 0xf9ad
leaq -0x30(%rbp), %rdi
callq 0x5190
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
nop
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: ModulusDefinition::argsMatch(NExpressionArgs*)
virtual bool argsMatch(NExpressionArgs *args) {
    return args && args->expr && args->expr->get_type()->cpp_type_string() == "int"
      && args->next && args->next->expr &&
      args->next->expr->get_type()->cpp_type_string() == "int"
      && args->next->next == NULL;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb $0x0, -0x39(%rbp)
movb $0x0, -0x6d(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x6e(%rbp)
je 0xfb91
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x6e(%rbp)
je 0xfb91
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movb $0x1, -0x39(%rbp)
leaq -0x38(%rbp), %rdi
leaq 0x6f5c(%rip), %rsi      # 0x16a54
callq 0xb630
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6e(%rbp)
jne 0xfb0e
jmp 0xfb91
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x6e(%rbp)
je 0xfb91
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x6e(%rbp)
je 0xfb91
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0xfb4a
movq -0x78(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xfb5c
movb $0x1, -0x6d(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x6ee9(%rip), %rsi      # 0x16a54
callq 0xb630
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6e(%rbp)
jne 0xfb7e
jmp 0xfb91
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0x6e(%rbp)
movb -0x6e(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x6d(%rbp)
jne 0xfba1
jmp 0xfbaa
leaq -0x60(%rbp), %rdi
callq 0x5190
testb $0x1, -0x39(%rbp)
jne 0xfbb2
jmp 0xfbbb
leaq -0x38(%rbp), %rdi
callq 0x5190
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xfbdd
jmp 0xfbe6
leaq -0x38(%rbp), %rdi
callq 0x5190
jmp 0xfbe8
movq -0x68(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: RangeDefinition::generateItrCallForArgs(NIdentifier*, NExpressionArgs*)
virtual void generateItrCallForArgs(NIdentifier *id, NExpressionArgs *args) {
    cout << "for (int " << id->name << " = ";

    if (args->next) {
      // Double argument range
      args->expr->generate();
      args = args->next;
    } else {
      // Single argument range
      cout << '0';
    }

    cout << "; " << id->name << " < ";
    args->expr->generate();
    // Big hack to make it behave like the Python range iterable
    // Please don't ask
    cout << " || (" << id->name << "-- && false)"
         << "; " << id->name << "++) {" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xf075(%rip), %rdi      # 0x1efc0
leaq 0x6bba(%rip), %rsi      # 0x16b0c
callq 0x5210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, %rdi
leaq 0x6ba5(%rip), %rsi      # 0x16b16
callq 0x5210
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xff9c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xffad
movq 0xf01d(%rip), %rdi      # 0x1efc0
movl $0x30, %esi
callq 0x5280
movq 0xf00c(%rip), %rdi      # 0x1efc0
leaq 0x6b5f(%rip), %rsi      # 0x16b1a
callq 0x5210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, %rdi
leaq 0x6b43(%rip), %rsi      # 0x16b1d
callq 0x5210
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xefcd(%rip), %rdi      # 0x1efc0
leaq 0x6b27(%rip), %rsi      # 0x16b21
callq 0x5210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, %rdi
leaq 0x6b0e(%rip), %rsi      # 0x16b27
callq 0x5210
movq %rax, %rdi
leaq 0x6af2(%rip), %rsi      # 0x16b1a
callq 0x5210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, %rdi
leaq 0x6aed(%rip), %rsi      # 0x16b34
callq 0x5210
movq %rax, %rdi
movq 0xef4a(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: LenDefinition::argsMatch(NExpressionArgs*)
virtual bool argsMatch(NExpressionArgs *args) {
    if (args == NULL && args->next != NULL) {
      return false;
    }
    // Throws up if the type has no len
    args->expr->get_type()->get_cpp_len_function();
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10308
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10308
movb $0x0, -0x1(%rbp)
jmp 0x1032e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x30(%rax)
leaq -0x38(%rbp), %rdi
callq 0x5190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: LenDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    Type *type = args->expr->get_type();
    std::cout << '(';
    args->expr->generate();
    std::cout << ')' << type->get_cpp_len_function();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x18(%rbp)
movq 0xec56(%rip), %rdi      # 0x1efc0
movq %rdi, -0x60(%rbp)
movl $0x28, %esi
callq 0x5280
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x60(%rbp), %rdi
movl $0x29, %esi
callq 0x5280
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq *%rax
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x51f0
jmp 0x103be
leaq -0x38(%rbp), %rdi
callq 0x5190
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x40(%rbp), %rdi
callq 0x5400
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NExpression::generate_itr_header(NIdentifier*)
void NExpression::generate_itr_header(NIdentifier *id) {
  Type *t = get_type();
  if (t->isIndexible()) {
    t = ((ListType *)t)->get_itr_type();
  }
  // Default for header
  cout << "for (" << t->cpp_type_string() << ' ' << id->name << " : ";
  generate();
  cout << ") {" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x11c24
jmp 0x11c32
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x18(%rbp)
movq 0xd387(%rip), %rdi      # 0x1efc0
leaq 0x50ab(%rip), %rsi      # 0x16ceb
callq 0x5210
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x51f0
movq %rax, -0x58(%rbp)
jmp 0x11c70
movq -0x58(%rbp), %rdi
movl $0x20, %esi
callq 0x5280
movq %rax, -0x70(%rbp)
jmp 0x11c84
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, -0x78(%rbp)
jmp 0x11c9b
movq -0x78(%rbp), %rdi
leaq 0x4b41(%rip), %rsi      # 0x167e7
callq 0x5210
jmp 0x11cad
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xd2f9(%rip), %rdi      # 0x1efc0
leaq 0x4b33(%rip), %rsi      # 0x16801
callq 0x5210
movq %rax, %rdi
movq 0xd2c3(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x40(%rbp), %rdi
callq 0x5400
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NFunctionCallExpression::get_type()
Type* NFunctionCallExpression::get_type() {
  Definition *d = scope->findDefinition(id->name);
  if ( ! d->isFunction()) {
    throw std::runtime_error(id->name + " is not a function");
  }
  return ((FunctionDefinition *)d)->get_type();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x80(%rbp)
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5100
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x70(%rbp)
jmp 0x122cd
leaq -0x30(%rbp), %rdi
callq 0x5190
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x123aa
movb $0x1, -0x61(%rbp)
movl $0x10, %edi
callq 0x5130
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq 0x4a65(%rip), %rdx      # 0x16d82
leaq -0x60(%rbp), %rdi
callq 0x13930
jmp 0x12328
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5390
jmp 0x1233a
movq -0x90(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0xcc9c(%rip), %rsi      # 0x1efe8
movq 0xcc65(%rip), %rdx      # 0x1efb8
callq 0x53d0
jmp 0x123c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5190
jmp 0x123bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x12394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5190
testb $0x1, -0x61(%rbp)
jne 0x1239c
jmp 0x123a8
movq -0x90(%rbp), %rdi
callq 0x51b0
jmp 0x123bd
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NAssignment::generate(int)
void NAssignment::generate(int level) {
  NStatement::generate(level);

  // Only declare the type if it's not a root statement
  // Otherwise, a header is declared at the top of the file
  // Also, don't declare the type if the variable is already declared
  Definition *def = scope->findDefinition(lhs->name);
  VariableDefinition *vdef = (VariableDefinition *)def;

  if (! vdef->hasGeneratedHeader) {
    // Earthquake, ignore it
    cout << lhs->get_type()->cpp_type_string() << " ";
                vdef->hasGeneratedHeader = true;
  }
  lhs->generate();
  cout << " = ";
  rhs->generate();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5100
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0x127e5
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x128a7
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq *%rax
movq -0xa0(%rbp), %rsi
movq 0xc77d(%rip), %rdi      # 0x1efc0
callq 0x51f0
movq %rax, -0x98(%rbp)
jmp 0x12851
movq -0x98(%rbp), %rdi
leaq 0x3c40(%rip), %rsi      # 0x1649f
callq 0x5210
jmp 0x12866
leaq -0x70(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rax
movb $0x1, 0x10(%rax)
jmp 0x128a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
jmp 0x12907
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5190
jmp 0x12907
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xc701(%rip), %rdi      # 0x1efc0
leaq 0x4250(%rip), %rsi      # 0x16b16
callq 0x5210
movq -0x90(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xc6dd(%rip), %rdi      # 0x1efc0
leaq 0x44cb(%rip), %rsi      # 0x16db5
callq 0x5210
movq %rax, %rdi
movq 0xc6a7(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5400
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NFunctionCallExpression::generate_itr_header(NIdentifier*)
void NFunctionCallExpression::generate_itr_header(NIdentifier *id) {
  FunctionDefinition *def = (FunctionDefinition *)scope->findDefinition(this->id->name);
  if (def->hasCustomIterator()) {
    def->generateItrCallForArgs(id, args);
  } else {
    NExpression::generate_itr_header(id);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5100
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x12ddb
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x12dfc
jmp 0x12e2b
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdx
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x12e38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
jmp 0x12e3e
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11bf0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5400
nopw (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NList::generate_itr_header(NIdentifier*)
virtual void generate_itr_header(NIdentifier *id) {
    Type *t = type->get_itr_type();
    cout << "for (" << t->cpp_type_string() << ' ' << id->name << " : ";
    generate();
    cout << ") {" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x18(%rbp)
movq 0xb47d(%rip), %rdi      # 0x1efc0
leaq 0x31a1(%rip), %rsi      # 0x16ceb
callq 0x5210
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq *%rax
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x51f0
movq %rax, -0x50(%rbp)
jmp 0x13b7a
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x5280
movq %rax, -0x70(%rbp)
jmp 0x13b8e
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, -0x78(%rbp)
jmp 0x13ba5
movq -0x78(%rbp), %rdi
leaq 0x2c37(%rip), %rsi      # 0x167e7
callq 0x5210
jmp 0x13bb7
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xb3ef(%rip), %rdi      # 0x1efc0
leaq 0x2c29(%rip), %rsi      # 0x16801
callq 0x5210
movq %rax, %rdi
movq 0xb3b9(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5190
movq -0x40(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NReturn::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "return ";
    if (expr) expr->generate();
    cout << ';' << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq 0xb0ca(%rip), %rdi      # 0x1efc0
leaq 0x2f71(%rip), %rsi      # 0x16e6e
callq 0x5210
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13f1b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xb09e(%rip), %rdi      # 0x1efc0
movl $0x3b, %esi
callq 0x5280
movq %rax, %rdi
movq 0xb06a(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NForStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    Type *itr_type = iterable->get_type()->get_itr_type();

    iterable->generate_itr_header(itr_name);
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq 0x10(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbeb0
movq 0xaffc(%rip), %rdi      # 0x1efc0
leaq 0x2530(%rip), %rsi      # 0x164fb
callq 0x5210
movq %rax, %rdi
movq 0xafc6(%rip), %rsi      # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: skyetheguy[P]gait_cycle_phase_detection/gaitCycle.cpp
// Function: gaitCycle::isToeOff(float, int)
bool gaitCycle::isToeOff(float zAccel, int currTime)
{
	if (zAccel > 15500 && (currTime - lastStateChangeTime) > 150)
	{
		lastStateChangeTime = currTime;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
movss 0x1bdf(%rip), %xmm1     # 0x6054
ucomiss %xmm1, %xmm0
jbe 0x44a1
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
subl 0x274(%rcx), %eax
cmpl $0x96, %eax
jle 0x44a1
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x274(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x44a5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: skyetheguy[P]gait_cycle_phase_detection/gaitCycle.cpp
// Function: gaitCycle::isHeelStrike(float, int)
bool gaitCycle::isHeelStrike(float zAccel, int currTime)
{
	if (zAccel < 3000 && (currTime - lastStateChangeTime) > 150)
	{
		lastStateChangeTime = currTime;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x1b88(%rip), %xmm0     # 0x6058
ucomiss -0x14(%rbp), %xmm0
jbe 0x44fd
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
subl 0x274(%rcx), %eax
cmpl $0x96, %eax
jle 0x44fd
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x274(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4501
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: skyetheguy[P]gait_cycle_phase_detection/processSignal.cpp
// Function: processSignal::updateState(int, float)
void processSignal::updateState(int time, float sensorValue)
{

	if (dataRecord.size() < 5)
	{
		dataRecord.push_back(sensorValue);
	}
	else
	{
		dataRecord.push_back(sensorValue);
		dataRecord.pop_front();
	}


	lastDirection = direction;
	lastTime = currTime;


	currTime = time;

	if (lastReading < smoothData)
	{
		direction = 0;
	}
	else 
	{
		direction = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x4c80
cmpq $0x5, %rax
jae 0x4aae
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4cb0
jmp 0x4acc
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4cb0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x4d10
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movss 0x4(%rax), %xmm1
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4afd
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x4b08
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: skyetheguy[P]gait_cycle_phase_detection/processSignal.cpp
// Function: processSignal::isFlat()
bool processSignal::isFlat()
{
	if (dataRecord.size() < 4)
	{
		return false;
	}

	for (int i=0 ; i<= 3 ; i++)
	{
		for (int x= i+1 ; x<=4 ; x++)
		{
			if (abs(dataRecord[i] - dataRecord[x]) > 30)
			{
				return false;
			}
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x4c80
cmpq $0x4, %rax
jae 0x4bcc
movb $0x0, -0x1(%rbp)
jmp 0x4c52
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0x4c4e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jg 0x4c41
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4da0
movq -0x20(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4da0
movss -0x24(%rbp), %xmm0
subss (%rax), %xmm0
callq 0x4d80
movss 0x1507(%rip), %xmm1     # 0x6130
ucomiss %xmm1, %xmm0
jbe 0x4c34
movb $0x0, -0x1(%rbp)
jmp 0x4c52
jmp 0x4c36
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4be2
jmp 0x4c43
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4bd3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: main
int main(int argc, char** argv) {
    // Initialize better output for the console if we're on Windows
    init();

    // The command loop is very simple. Convert arguements into individual std::string components,
    // recursively call process_todos until no commands are left.

    std::queue<std::string>* commands = proc_commands(argv, argc);
    if(commands->empty()) {
        read_todos(true);
    } else {
        process_todos(commands, true);
    }
    delete commands;            

    return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x150e0
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x15180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x171f0
testb $0x1, %al
jne 0x1512a
jmp 0x15136
movl $0x1, %edi
callq 0x15290
jmp 0x15144
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x155c0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x15169
movq -0x20(%rbp), %rdi
callq 0x17210
movq -0x20(%rbp), %rdi
movl $0x50, %esi
callq 0x19db0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: proc_commands[abi:cxx11](char**, int)
std::queue<std::string>* proc_commands(char** argv, int argc) {
    std::queue<std::string>* res = new std::queue<std::string>();
    for(int i = 1; i < argc; i++) {
        res->push(std::string(argv[i]));
    }

    return res;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x50, %edi
callq 0x1ae10
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x17230
jmp 0x151aa
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15273
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1b280
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x17290
jmp 0x151fd
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x17260
jmp 0x1520c
leaq -0x48(%rbp), %rdi
callq 0x89820
leaq -0x49(%rbp), %rdi
callq 0x1b2a0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x151b9
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x19db0
jmp 0x1527d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x89820
leaq -0x49(%rbp), %rdi
callq 0x1b2a0
jmp 0x1527d
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)