LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/types.cpp
// Function: make_object(Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<object, std::allocator<object>>)
object make_object(Type type_, std::string value, std::vector<object> list) 
{
    object obj;
    obj.type = type_;

    if (type_ == BOP_LIST) 
    {
        obj.list = list;
    } 
    else 
    {
        obj.value = value;
    }
    return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movl %esi, (%rdi)
cmpl $0x2, %esi
jne 0x11f5c
leaq 0x28(%rbx), %rdi
movq %rcx, %rsi
callq 0x2fd0
jmp 0x11f68
leaq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x2150
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d8e
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NFunctionDeclStatement::generateHeader()
void generateHeader() {
    NStatement::generate(0);

    cout << type->cpp_type_string() << ' ' << id->name << '(';
    if (args) args->generate();
    cout << ");\n";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xc302(%rip), %rdi      # 0x14fc8
callq 0x5220
leaq -0x11(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
movq 0x10(%rbx), %rcx
movq 0x10(%rcx), %rsi
movq 0x18(%rcx), %rdx
movq %rax, %rdi
callq 0x5220
leaq -0x11(%rbp), %rsi
movb $0x28, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d19
callq 0x51b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8d28
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xc299(%rip), %rdi      # 0x14fc8
leaq 0x6b10(%rip), %rsi      # 0xf846
movl $0x3, %edx
callq 0x5220
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d5e
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NListIndex::generate()
virtual void generate() {
    list_expr->generate();
    cout << "[";
    index->generate();
    cout << "]";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xbe1f(%rip), %r14      # 0x14fc8
leaq 0x627b(%rip), %rsi      # 0xf42b
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x625f(%rip), %rsi      # 0xf42d
movl $0x1, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5220
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NWhileStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "while (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x943b
movq 0xbbac(%rip), %r14      # 0x14fc8
leaq 0x5fb7(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x9426
movq 0xbb86(%rip), %r14      # 0x14fc8
leaq 0x5fe6(%rip), %rsi      # 0xf42f
movl $0x7, %edx
movq %r14, %rdi
callq 0x5220
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x62f7(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq 0x18(%r15), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x94cd
movq 0xbb16(%rip), %r15      # 0x14fc8
leaq 0x5f21(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %ebx
jne 0x94b9
leaq 0x5f63(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5150
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NIfStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x9553
movq 0xba94(%rip), %r15      # 0x14fc8
leaq 0x5e9f(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x953e
movq 0xba6e(%rip), %r15      # 0x14fc8
leaq 0x5edd(%rip), %rsi      # 0xf43e
movl $0x4, %edx
movq %r15, %rdi
callq 0x5220
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x61df(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq %r14, -0x30(%rbp)
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x95ed
movq 0xb9fa(%rip), %r12      # 0x14fc8
leaq 0x5e05(%rip), %r13      # 0xf3da
movl %ebx, %r14d
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x5220
decl %r14d
jne 0x95d8
leaq 0x5e43(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
jne 0x963e
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x9656
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x96a3
movq 0xb944(%rip), %r15      # 0x14fc8
leaq 0x5d4f(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x968e
movq 0xb91e(%rip), %r15      # 0x14fc8
leaq 0x5d88(%rip), %rsi      # 0xf439
movl $0x9, %edx
movq %r15, %rdi
callq 0x5220
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x608f(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq %r14, -0x30(%rbp)
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x973d
movq 0xb8aa(%rip), %r12      # 0x14fc8
leaq 0x5cb5(%rip), %r13      # 0xf3da
movl %ebx, %r14d
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x5220
decl %r14d
jne 0x9728
leaq 0x5cf3(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
jne 0x978e
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x97a6
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x97f3
movq 0xb7f4(%rip), %r14      # 0x14fc8
leaq 0x5bff(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x97de
movq 0xb7ce(%rip), %r14      # 0x14fc8
leaq 0x5c42(%rip), %rsi      # 0xf443
movl $0x6, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq 0x10(%r15), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x9867
movq 0xb77c(%rip), %r15      # 0x14fc8
leaq 0x5b87(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %ebx
jne 0x9853
leaq 0x5bc9(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5150
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xb378(%rip), %rdi      # 0x14fc8
callq 0x5220
movq %rax, %r14
leaq 0x577c(%rip), %rsi      # 0xf3db
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x5220
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c92
callq 0x51b0
cmpq $0x0, 0x10(%rbx)
je 0x9cbb
leaq -0x30(%rbp), %rsi
movb $0x2c, (%rsi)
movq 0xb321(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cd9
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xb14d(%rip), %rbx      # 0x14fc8
leaq 0x58b0(%rip), %rsi      # 0xf732
movl $0x11, %edx
movq %rbx, %rdi
callq 0x5220
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0x5220
leaq 0x589e(%rip), %rsi      # 0xf744
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
leaq 0x588e(%rip), %rsi      # 0xf748
movl $0x14, %edx
movq %rbx, %rdi
callq 0x5220
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x5886(%rip), %rsi      # 0xf75d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5150
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0xb900
testq %rax, %rax
jne 0xa09c
movq %r15, %rdi
movq %r14, %rsi
callq 0xba2c
movq %rbx, (%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x58ce(%rip), %rsi      # 0xf97e
leaq -0x88(%rbp), %rdi
movq %r14, %rdx
callq 0xa96a
leaq 0x58c5(%rip), %rsi      # 0xf98b
leaq -0x88(%rbp), %rdi
callq 0x5370
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xa0f4
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xa0ff
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xba2c
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x5877(%rip), %rcx      # 0xf9a7
leaq 0x5874(%rip), %rsi      # 0xf9ab
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5370
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xa167
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xa172
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0xae4e(%rip), %rsi      # 0x14ff0
movq 0xae17(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xa1ca
callq 0x51b0
jmp 0xa1ca
movq %rax, %r14
movb $0x1, %r15b
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xa1d8
callq 0x51b0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1ea
callq 0x51b0
testb %r15b, %r15b
jne 0xa20b
jmp 0xa213
movq %rax, %r14
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa20b
callq 0x51b0
jmp 0xa20b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xb900
testq %rax, %rax
je 0xa24f
movq 0x28(%rax), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
je 0xa294
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x9fb4
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa241
callq 0x51b0
jmp 0xa241
xorl %ebx, %ebx
jmp 0xa241
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa2a9
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %r14
testq %rsi, %rsi
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa388
leaq -0x68(%rbp), %r12
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
movq (%r13), %rax
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq *(%rax)
movq (%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax)
movq -0x40(%rbp), %rdx
cmpq -0x60(%rbp), %rdx
jne 0xa33e
movq -0x68(%rbp), %r13
testq %rdx, %rdx
je 0xa347
movq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x51e0
testl %eax, %eax
setne %r15b
jmp 0xa34a
movb $0x1, %r15b
movq -0x68(%rbp), %r13
jmp 0xa34a
xorl %r15d, %r15d
leaq -0x58(%rbp), %rax
cmpq %rax, %r13
je 0xa35b
movq %r13, %rdi
callq 0x51b0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xa36d
callq 0x51b0
testb %r15b, %r15b
jne 0xa390
movq 0x8(%rbx), %rbx
movq 0x10(%r14), %r14
testq %rbx, %rbx
je 0xa388
testq %r14, %r14
jne 0xa2e9
orq %r14, %rbx
sete %al
jmp 0xa392
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xa3b6
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rdi)
movq $0x1, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x3f800000, 0x28(%rdi) # imm = 0x3F800000
movups %xmm0, 0x30(%rdi)
movq %rsi, 0x40(%rdi)
leaq 0x9f48(%rip), %rax      # 0x14708
movq %rax, (%rdi)
callq 0xa46e
movq 0x10(%r14), %rax
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x9fb4
movl $0x10, %edi
callq 0x51d0
leaq 0x9f27(%rip), %rcx      # 0x14720
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa054
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xa81d
callq 0x51b0
movq 0x18(%r14), %r12
testq %r12, %r12
je 0xa895
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %r14
leaq 0x9e9b(%rip), %r13      # 0x146d0
movq 0x8(%r12), %rax
movq %r15, -0x48(%rbp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x9fb4
movl $0x20, %edi
callq 0x51d0
movq 0x18(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %r13, (%rax)
movq %r12, 0x18(%rax)
movb $0x1, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa054
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa88b
callq 0x51b0
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xa835
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0xa8bb
jmp 0xa8af
movq %rax, %r14
jmp 0xa8c5
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa8c5
callq 0x51b0
leaq 0x9f0c(%rip), %rax      # 0x147d8
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xb860
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
addq $0x8, %rdi
callq 0xb900
testq %rax, %rax
je 0xa8fc
movq 0x28(%rax), %rax
jmp 0xa8fe
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%rbx)
je 0xaa30
leaq -0x9(%rbp), %rsi
movb $0x2c, (%rsi)
movq 0xa5ab(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x8(%rbx), %rdi
callq 0xa9f6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0xab51
movq %rsi, %rbx
leaq -0x38(%rbp), %r12
leaq -0x48(%rbp), %r14
leaq 0x498c(%rip), %r15      # 0xf482
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5090
testl %eax, %eax
je 0xab30
movq %r14, %rdi
leaq 0x4e8f(%rip), %rsi      # 0xf9b1
callq 0x5090
testl %eax, %eax
je 0xab30
xorl %r13d, %r13d
jmp 0xab33
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xab41
callq 0x51b0
testb %r13b, %r13b
je 0xab54
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xaaf6
jmp 0xab54
movb $0x1, %r13b
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0xa44d(%rip), %rdi      # 0x14fc8
leaq 0x4e42(%rip), %rsi      # 0xf9c4
movl $0x9, %edx
callq 0x5220
testq %rbx, %rbx
je 0xabdf
movq 0xa430(%rip), %r14      # 0x14fc8
leaq 0x4e2f(%rip), %r15      # 0xf9ce
leaq 0x4e2d(%rip), %r12      # 0xf9d3
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%rbx)
je 0xabdf
movl $0x7, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xaba6
movq 0xa3e2(%rip), %rdi      # 0x14fc8
leaq 0x4dee(%rip), %rsi      # 0xf9db
movl $0xd, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0xace5
cmpq $0x0, 0x8(%rsi)
je 0xacf0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4ca3(%rip), %rsi      # 0xf9b1
movq %rbx, %rdi
callq 0x5090
testl %eax, %eax
je 0xad31
leaq 0x4761(%rip), %rsi      # 0xf482
leaq -0x28(%rbp), %rdi
callq 0x5090
testl %eax, %eax
sete %bl
jmp 0xad33
movb $0x1, %bl
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xace7
callq 0x51b0
jmp 0xace7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x470e(%rip), %rsi      # 0xf482
movq %r14, %rdi
callq 0x5090
testl %eax, %eax
je 0xada2
leaq 0x4c2a(%rip), %rsi      # 0xf9b1
leaq -0x38(%rbp), %rdi
callq 0x5090
testl %eax, %eax
jne 0xadba
movl $0xf, %edx
leaq 0x4c5c(%rip), %rsi      # 0xf9fc
jmp 0xadae
movl $0xc, %edx
leaq 0x4c41(%rip), %rsi      # 0xf9ef
movq 0xa213(%rip), %rdi      # 0x14fc8
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x11(%rbp), %rsi
movb $0x29, (%rsi)
movq 0xa1f7(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaded
callq 0x51b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xae0b
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4518(%rip), %rsi      # 0xf482
movq %r14, %rdi
callq 0x5090
testl %eax, %eax
je 0xaf95
leaq 0x4a34(%rip), %rsi      # 0xf9b1
leaq -0x38(%rbp), %rdi
callq 0x5090
testl %eax, %eax
jne 0xafce
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xafce
movq 0xa02c(%rip), %rdi      # 0x14fc8
leaq 0x4a69(%rip), %rsi      # 0xfa0c
movl $0xa, %edx
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x11(%rbp), %rsi
movb $0x29, (%rsi)
movq 0xa004(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafe0
callq 0x51b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaffe
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
testq %rsi, %rsi
je 0xb102
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xb102
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x48d1(%rip), %rsi      # 0xf9b1
movq %r14, %rdi
callq 0x5090
testl %eax, %eax
je 0xb10f
xorl %ebx, %ebx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb104
callq 0x51b0
jmp 0xb104
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xb0ec
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0ec
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4879(%rip), %rsi      # 0xf9b1
leaq -0x30(%rbp), %rdi
callq 0x5090
testl %eax, %eax
je 0xb149
xorl %ebx, %ebx
jmp 0xb155
movq 0x8(%rbx), %rax
cmpq $0x0, 0x8(%rax)
sete %bl
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb0ee
callq 0x51b0
jmp 0xb0ee
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb17e
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x9bd6(%rip), %r15      # 0x14fc8
leaq 0x4670(%rip), %rsi      # 0xfa69
movl $0x9, %edx
movq %r15, %rdi
callq 0x5220
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r15, %rdi
callq 0x5220
leaq 0x4656(%rip), %rsi      # 0xfa73
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
cmpq $0x0, 0x8(%r14)
je 0xb440
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%r14), %r14
jmp 0xb458
leaq -0x21(%rbp), %rsi
movb $0x30, (%rsi)
movq 0x9b7a(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x9b69(%rip), %r12      # 0x14fc8
leaq 0x4611(%rip), %r15      # 0xfa77
movl $0x2, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5220
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r12, %rdi
callq 0x5220
leaq 0x45ed(%rip), %rsi      # 0xfa7a
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x45d4(%rip), %rsi      # 0xfa7e
movl $0x5, %edx
movq %r12, %rdi
callq 0x5220
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r12, %rdi
callq 0x5220
movq %rax, %r14
leaq 0x45b3(%rip), %rsi      # 0xfa84
movl $0xc, %edx
movq %rax, %rdi
callq 0x5220
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5220
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x5220
movq %rax, %rbx
leaq 0x4589(%rip), %rsi      # 0xfa91
movl $0x5, %edx
movq %rax, %rdi
callq 0x5220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0xb795
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rbx), %rdi
leaq -0x18(%rbp), %rax
movb $0x1, %bl
cmpq %rax, %rdi
je 0xb7a2
callq 0x51b0
jmp 0xb7a2
cmpq $0x0, 0x8
je 0xb768
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movb $0x28, (%r15)
movq 0x97f0(%rip), %r12      # 0x14fc8
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5220
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb $0x29, (%r15)
leaq -0x40(%rbp), %rsi
movl $0x1, %edx
movq %r12, %rdi
callq 0x5220
movq %rax, %r14
movq (%rbx), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x5220
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb836
callq 0x51b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb858
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
callq *0x20(%rax)
testb %al, %al
je 0xbdd9
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %rax, %r12
movq 0x91e8(%rip), %r14      # 0x14fc8
leaq 0x3e60(%rip), %rsi      # 0xfc47
movl $0x5, %edx
movq %r14, %rdi
callq 0x5220
movq (%r12), %rax
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq *(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x5220
leaq -0x29(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rax, %rdi
callq 0x5220
leaq 0x3905(%rip), %rsi      # 0xf744
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbe5e
callq 0x51b0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x38f0(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbec6
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NReturn::NReturn(NExpression*)
NReturn::NReturn(NExpression *expr) : expr(expr) {
  if (funcStack == NULL) {
    throw std::runtime_error("Return statement outside of function");
  }

  Type *type = expr ? expr->get_type() : new VoidType();
  Type *declaredType = funcStack->get_type();

  if (declaredType->isUnset()) {
    // Type implication on first return
    NFunctionDeclStatement *funcDecl = funcStack->stmt;
    funcDecl->type = type;
    funcStack->set_type(type);
  } else {
    if (expr == NULL && ! declaredType->isVoid()) {
      throw std::runtime_error("Cannot return a value on a void function");
    } else if (expr != NULL) {
      expr->set_type(declaredType);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x9344(%rip), %rax      # 0x152d8
movq (%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x8c26(%rip), %rax      # 0x14bc8
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x9330(%rip), %r12      # 0x152e0
movq (%r12), %r15
testq %r15, %r15
je 0xc04f
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbfd6
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, %r14
movq (%r12), %r15
jmp 0xbfed
movl $0x8, %edi
callq 0x51d0
movq %rax, %r14
leaq 0x8216(%rip), %rax      # 0x14200
movq %rax, (%r14)
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xc01d
movq (%r12), %rdi
movq 0x20(%rdi), %rax
movq %r14, 0x20(%rax)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
jmp 0xc02f
testq %rbx, %rbx
je 0xc039
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testb %al, %al
je 0xc081
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x3bea(%rip), %rsi      # 0xfc4d
movq %rax, %rdi
callq 0x50e0
movq 0x8f7e(%rip), %rsi      # 0x14ff0
movq 0x8f47(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x3bdd(%rip), %rsi      # 0xfc72
movq %rax, %rdi
callq 0x50e0
jmp 0xc06b
jmp 0xc0a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NFunctionCallExpression::NFunctionCallExpression(NIdentifier*, NExpressionArgs*)
NFunctionCallExpression::
NFunctionCallExpression(NIdentifier *id, NExpressionArgs *args):
    id(id), args(args) {
  Definition *def = scope->findDefinition(id->name);
  if (def == NULL) {
    throw std::runtime_error(id->name + " function is undefined");
  }
  if ( ! def->isFunction()) {
    throw std::runtime_error(id->name + " is not defined as a function");
  }
  if ( ! ((FunctionDefinition *)def)->argsMatch(args)) {
    throw std::runtime_error("Type mismatch");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x9206(%rip), %rax      # 0x152d8
movq (%rax), %r15
movq %r15, 0x8(%rdi)
leaq 0x8b08(%rip), %rax      # 0x14be8
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsi), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x9fb4
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xc126
callq 0x51b0
addq $0x10, %rbx
testq %r15, %r15
je 0xc15e
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testb %al, %al
je 0xc1a8
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0xc1f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %r14
leaq 0x3b29(%rip), %rdx      # 0xfc9b
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xd23c
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8e59(%rip), %rsi      # 0x14ff0
movq 0x8e22(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
jmp 0xc1f0
movl $0x10, %edi
callq 0x5120
movq %rax, %r14
leaq 0x3af6(%rip), %rdx      # 0xfcb2
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xd23c
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8e0f(%rip), %rsi      # 0x14ff0
movq 0x8dd8(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
movl $0x10, %edi
callq 0x5120
movq %rax, %r14
leaq 0x3acc(%rip), %rsi      # 0xfcd0
movq %rax, %rdi
callq 0x50e0
movq 0x8ddd(%rip), %rsi      # 0x14ff0
movq 0x8da6(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
jmp 0xc244
jmp 0xc228
jmp 0xc244
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc23d
callq 0x51b0
testb %r15b, %r15b
jne 0xc247
jmp 0xc262
movq %rax, %rbx
movq %r14, %rdi
callq 0x5170
jmp 0xc262
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xc262
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %rax
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x9fb4
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc2c0
callq 0x51b0
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
je 0xc2e2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
movq 0x10(%r14), %rsi
addq $0x10, %rsi
leaq 0x39e0(%rip), %rdx      # 0xfcde
leaq -0x60(%rbp), %rdi
callq 0xd23c
movb $0x1, %r15b
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8cd0(%rip), %rsi      # 0x14ff0
movq 0x8c99(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc344
callq 0x51b0
testb %r15b, %r15b
jne 0xc34e
jmp 0xc369
movq %rax, %r14
movq %rbx, %rdi
callq 0x5170
jmp 0xc369
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc369
callq 0x51b0
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0xc702
movl %esi, %r14d
movq 0x88e2(%rip), %r15      # 0x14fc8
leaq 0x2ced(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r14d
jne 0xc6ed
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rax
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x9fb4
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc746
callq 0x51b0
cmpb $0x0, 0x10(%r14)
jne 0xc7a3
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x8855(%rip), %rdi      # 0x14fc8
callq 0x5220
leaq 0x2c5c(%rip), %rsi      # 0xf3db
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc79e
callq 0x51b0
movb $0x1, 0x10(%r14)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8814(%rip), %r14      # 0x14fc8
leaq 0x32b8(%rip), %rsi      # 0xfa73
movl $0x3, %edx
movq %r14, %rdi
callq 0x5220
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x3538(%rip), %rsi      # 0xfd11
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc838
jmp 0xc83d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc83d
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop