LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9c02(%rip), %rax      # 0x13708
movq %rax, (%rdi)
callq 0x9848
movq 0x10(%r14), %rsi
addq $0x10, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5290
pushq $0x10
popq %rdi
callq 0x51f0
leaq 0x9bf2(%rip), %rcx      # 0x13720
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9560
leaq -0x48(%rbp), %rdi
callq 0x5120
addq $0x18, %r14
leaq -0x68(%rbp), %r15
pushq $0x20
popq %r12
leaq 0x9b70(%rip), %r13      # 0x136d0
movq (%r14), %r14
testq %r14, %r14
je 0x9baf
movq 0x8(%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x5290
movq %r12, %rdi
callq 0x51f0
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %r13, (%rax)
movq %r14, 0x18(%rax)
movb $0x1, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9560
movq %r15, %rdi
callq 0x5120
addq $0x10, %r14
jmp 0x9b60
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0x9bd5
jmp 0x9bc9
movq %rax, %r14
jmp 0x9bda
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x9d14
movq %r14, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa910
testq %rax, %rax
je 0x9c02
movq 0x28(%rax), %rax
jmp 0x9c04
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa2e4(%rip), %r14      # 0x13fc8
pushq $0x2c
popq %r15
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%rbx)
je 0x9d09
movq %r14, %rdi
movl %r15d, %esi
callq 0x5220
movq 0x8(%rbx), %rbx
jmp 0x9ce8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq -0x40(%rbp), %r14
leaq 0x46a5(%rip), %r15      # 0xe482
leaq 0x4bcd(%rip), %r12      # 0xe9b1
testq %rbx, %rbx
je 0x9e31
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 0x9eea
testb %al, %al
je 0x9e1a
movq %r14, %rdi
movq %r12, %rsi
callq 0x9eea
testb %al, %al
jne 0x9e28
movq %r14, %rdi
callq 0x5120
movq 0x8(%rbx), %rbx
jmp 0x9de4
leaq -0x40(%rbp), %rdi
callq 0x5120
testq %rbx, %rbx
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq 0xa158(%rip), %rbx      # 0x13fc8
leaq 0x4b4d(%rip), %rsi      # 0xe9c4
movq %rbx, %rdi
callq 0x51e0
leaq 0x4b48(%rip), %r14      # 0xe9ce
leaq 0x4b46(%rip), %r15      # 0xe9d3
testq %r12, %r12
je 0x9ec9
movq %r12, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51e0
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%r12)
movl $0x0, %r12d
je 0x9e8d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51e0
movq 0x8(%r13), %r12
jmp 0x9e8d
movq 0xa0f8(%rip), %rdi      # 0x13fc8
leaq 0x4b04(%rip), %rsi      # 0xe9db
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9fb9
cmpq $0x0, 0x8(%rsi)
je 0x9fbd
xorl %ebx, %ebx
jmp 0xa004
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x49d6(%rip), %rsi      # 0xe9b1
movq %rbx, %rdi
callq 0x85f0
movb $0x1, %bl
testb %al, %al
jne 0x9ffb
leaq 0x4492(%rip), %rsi      # 0xe482
leaq -0x28(%rbp), %rdi
callq 0x85f0
movl %eax, %ebx
leaq -0x28(%rbp), %rdi
callq 0x5120
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4448(%rip), %rsi      # 0xe482
movq %r14, %rdi
callq 0x85f0
testb %al, %al
je 0xa04f
leaq 0x49a2(%rip), %rsi      # 0xe9ef
jmp 0xa06a
leaq 0x495b(%rip), %rsi      # 0xe9b1
leaq -0x30(%rbp), %rdi
callq 0x85f0
testb %al, %al
je 0xa076
leaq 0x4992(%rip), %rsi      # 0xe9fc
movq 0x9f57(%rip), %rdi      # 0x13fc8
callq 0x51e0
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x9f42(%rip), %rdi      # 0x13fc8
pushq $0x29
popq %rsi
callq 0x5220
leaq -0x30(%rbp), %rdi
callq 0x5120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x42be(%rip), %rsi      # 0xe482
movq %r14, %rdi
callq 0x85f0
testb %al, %al
je 0xa1fd
movq 0x9df1(%rip), %rdi      # 0x13fc8
leaq 0x482e(%rip), %rsi      # 0xea0c
callq 0x51e0
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x9dd5(%rip), %rdi      # 0x13fc8
pushq $0x29
popq %rsi
callq 0x5220
jmp 0xa21a
leaq 0x47ad(%rip), %rsi      # 0xe9b1
leaq -0x30(%rbp), %rdi
callq 0x85f0
testb %al, %al
je 0xa21a
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x30(%rbp), %rdi
callq 0x5120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa332
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xa332
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x46cf(%rip), %rsi      # 0xe9b1
movq %r14, %rdi
callq 0x85f0
testb %al, %al
je 0xa336
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa336
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa336
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x469a(%rip), %rsi      # 0xe9b1
leaq -0x30(%rbp), %rdi
callq 0x85f0
testb %al, %al
je 0xa34c
movq 0x8(%rbx), %rax
cmpq $0x0, 0x8(%rax)
sete %bl
jmp 0xa34e
xorl %ebx, %ebx
jmp 0xa341
xorl %ebx, %ebx
leaq -0x50(%rbp), %rdi
callq 0x5120
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x30(%rbp), %rdi
callq 0x5120
jmp 0xa338
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %r14
movq %rsi, %rbx
movq 0x9a62(%rip), %rdi      # 0x13fc8
leaq 0x44fc(%rip), %rsi      # 0xea69
callq 0x51e0
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51c0
leaq 0x44eb(%rip), %rsi      # 0xea73
movq %rax, %rdi
callq 0x51e0
cmpq $0x0, 0x8(%r14)
je 0xa5a6
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%r14), %r14
jmp 0xa5b5
movq 0x9a1b(%rip), %rdi      # 0x13fc8
pushq $0x30
popq %rsi
callq 0x5220
movq 0x9a0c(%rip), %r12      # 0x13fc8
leaq 0x44b4(%rip), %r15      # 0xea77
movq %r12, %rdi
movq %r15, %rsi
callq 0x51e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51c0
leaq 0x449a(%rip), %rsi      # 0xea7a
movq %rax, %rdi
callq 0x51e0
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x4486(%rip), %rsi      # 0xea7e
movq %r12, %rdi
callq 0x51e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51c0
leaq 0x4472(%rip), %rsi      # 0xea84
movq %rax, %rdi
callq 0x51e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x51e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51c0
leaq 0x445a(%rip), %rsi      # 0xea91
movq %rax, %rdi
callq 0x51e0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0x97e2(%rip), %r15      # 0x13fc8
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
pushq $0x29
popq %rsi
movq %r15, %rdi
callq 0x5220
movq %rax, %rbx
movq (%r14), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51c0
leaq -0x38(%rbp), %rdi
callq 0x5120
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x20(%rax)
testb %al, %al
je 0xae28
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rax, %r15
movq 0x9199(%rip), %rdi      # 0x13fc8
leaq 0x3e11(%rip), %rsi      # 0xec47
callq 0x51e0
movq %rax, %r12
movq (%r15), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5220
addq $0x10, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x51c0
leaq 0x38cb(%rip), %rsi      # 0xe744
movq %rax, %rdi
callq 0x51e0
leaq -0x48(%rbp), %rdi
callq 0x5120
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x912e(%rip), %rdi      # 0x13fc8
leaq 0x38bd(%rip), %rsi      # 0xe75e
callq 0x51e0
movq %rax, %rdi
callq 0x5130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9382(%rip), %rax      # 0x142f8
movq (%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x8c44(%rip), %rax      # 0x13bc8
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x936e(%rip), %r12      # 0x14300
movq (%r12), %r15
testq %r15, %r15
je 0xb02f
movq %rsi, %rbx
testq %rsi, %rsi
je 0xafb8
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, %r14
movq (%r12), %r15
jmp 0xafcd
pushq $0x8
popq %rdi
callq 0x51f0
movq %rax, %r14
leaq 0x8236(%rip), %rax      # 0x13200
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 0xaffd
movq (%r12), %rdi
movq 0x20(%rdi), %rax
movq %r14, 0x20(%rax)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
jmp 0xb00f
testq %rbx, %rbx
je 0xb019
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 0xb05f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
leaq 0x3c0c(%rip), %rsi      # 0xec4d
movq %rax, %rdi
callq 0x50d0
movq 0x8fa0(%rip), %rsi      # 0x13ff0
movq 0x8f69(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
leaq 0x3c01(%rip), %rsi      # 0xec72
movq %rax, %rdi
callq 0x50d0
jmp 0xb049
jmp 0xb07d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
movq %r14, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x924c(%rip), %rax      # 0x142f8
movq (%rax), %r15
movq %r15, 0x8(%rdi)
leaq 0x8b2e(%rip), %rax      # 0x13be8
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x10, %rbx
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5290
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
leaq -0x60(%rbp), %rdi
callq 0x5120
testq %r15, %r15
je 0xb121
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testb %al, %al
je 0xb169
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0xb1af
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %r14
leaq 0x3b68(%rip), %rdx      # 0xec9b
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xbd9e
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x8e98(%rip), %rsi      # 0x13ff0
movq 0x8e61(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x5350
jmp 0xb1af
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %r14
leaq 0x3b37(%rip), %rdx      # 0xecb2
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xbd9e
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x8e50(%rip), %rsi      # 0x13ff0
movq 0x8e19(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x5350
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %r14
leaq 0x3b0f(%rip), %rsi      # 0xecd0
movq %rax, %rdi
callq 0x50d0
movq 0x8e20(%rip), %rsi      # 0x13ff0
movq 0x8de9(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x5350
jmp 0xb1f8
jmp 0xb1e5
jmp 0xb1f8
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5120
testb %r15b, %r15b
jne 0xb1fb
jmp 0xb211
movq %rax, %rbx
movq %r14, %rdi
callq 0x5180
jmp 0xb211
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x5290
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5120
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
je 0xb279
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
movq 0x10(%r14), %rsi
addq $0x10, %rsi
leaq 0x3a4b(%rip), %rdx      # 0xecde
leaq -0x38(%rbp), %rdi
callq 0xbd9e
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x8d3b(%rip), %rsi      # 0x13ff0
movq 0x8d04(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x5120
testb %r15b, %r15b
jne 0xb2da
jmp 0xb2f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
jmp 0xb2f0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x8852
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x5290
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x5120
cmpb $0x0, 0x10(%r14)
jne 0xb5ed
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x8a00(%rip), %rdi      # 0x13fc8
movq %r15, %rsi
callq 0x51c0
leaq 0x2e04(%rip), %rsi      # 0xe3db
movq %rax, %rdi
callq 0x51e0
leaq -0x38(%rbp), %rdi
callq 0x5120
movb $0x1, 0x10(%r14)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x89ca(%rip), %r14      # 0x13fc8
leaq 0x346e(%rip), %rsi      # 0xea73
movq %r14, %rdi
callq 0x51e0
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x36f3(%rip), %rsi      # 0xed11
movq %r14, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xb649
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NIdentifier::set_type(Type*)
void NIdentifier::set_type(Type *type) {
  auto vd = (VariableDefinition *)scope->findDefinition(name);
  if (vd->get_type()->isUnset()) {
    vd->set_type(type);
  } else if (vd->get_type()->cpp_type_string() != type->cpp_type_string()) {
    throw std::runtime_error(name + " is already a "
                             + vd->type->cpp_type_string());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
addq $0x10, %r14
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5290
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
leaq -0xa8(%rbp), %rdi
callq 0x5120
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
testb %al, %al
je 0xb7ba
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
jmp 0xb806
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%rax), %rcx
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%rbx), %rax
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq *(%rax)
leaq -0x48(%rbp), %rbx
leaq -0x68(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8bdb
movl %eax, %r13d
movq %r12, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5120
testb %r13b, %r13b
jne 0xb818
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
leaq 0x34fe(%rip), %rdx      # 0xed28
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0xbd9e
movq 0x8(%r15), %rsi
movq (%rsi), %rax
leaq -0x88(%rbp), %rdi
callq *(%rax)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0xbdd6
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x877d(%rip), %rsi      # 0x13ff0
movq 0x8746(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x5120
jmp 0xb896
movq %rax, %r14
movb $0x1, %r15b
leaq -0x88(%rbp), %rdi
callq 0x5120
jmp 0xb8aa
movq %rax, %r14
movb $0x1, %r15b
leaq -0x68(%rbp), %rdi
callq 0x5120
testb %r15b, %r15b
jne 0xb8bd
jmp 0xb8df
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
jmp 0xb8df
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0xb8da
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x5290
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
leaq -0x40(%rbp), %rdi
callq 0x5120
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
testb %al, %al
je 0xb9b7
movq 0x18(%r14), %rdx
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
jmp 0xb9c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xadf0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NList::NList(NExpressionArgs*)
NList::NList(NExpressionArgs *contents) : contents(contents) {
  // Validate the type of the list - for now, you must have at least one element.
  if (contents == NULL) {
    throw std::runtime_error("No type associated with list declaration");
  } else {
    type = new ListType(contents->expr->get_type());
  }

  Type *itr_type = type->get_itr_type();
  for (contents = contents->next; contents != NULL; contents = contents->next) {
    Type *content_type = contents->expr->get_type();
    if (content_type->cpp_type_string() != itr_type->cpp_type_string()) {
      throw std::runtime_error("Type mismatch in " + itr_type->cpp_type_string() + " list");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x8848(%rip), %rax      # 0x142f8
movq (%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x817a(%rip), %rax      # 0x13c38
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
testq %rsi, %rsi
je 0xbbd0
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x10
popq %rdi
callq 0x51f0
movq %rax, %r12
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
leaq 0x7fef(%rip), %rax      # 0x13ae0
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %r12, 0x18(%r15)
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %r12
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xbbc1
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8bdb
movl %eax, %r13d
movq %r12, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x5120
testb %r13b, %r13b
je 0xbb06
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
movq (%r14), %rax
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x31eb(%rip), %rsi      # 0xed60
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x8be8
leaq 0x31e6(%rip), %rdx      # 0xed72
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x91c8
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x843e(%rip), %rsi      # 0x13ff0
movq 0x8407(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
leaq 0x3155(%rip), %rsi      # 0xed37
movq %rax, %rdi
callq 0x50d0
movq 0x83ff(%rip), %rsi      # 0x13ff0
movq 0x83c8(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
jmp 0xbc47
movq %rax, %r14
movq %r12, %rdi
callq 0x51d0
jmp 0xbc60
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x5120
jmp 0xbc23
movq %rax, %r14
movb $0x1, %r15b
leaq -0x68(%rbp), %rdi
callq 0x5120
jmp 0xbc34
movq %rax, %r14
movb $0x1, %r15b
leaq -0x88(%rbp), %rdi
callq 0x5120
testb %r15b, %r15b
jne 0xbc4a
jmp 0xbc60
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
jmp 0xbc60
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/node.cpp
// Function: NOpType_str[abi:cxx11](NOpType)
string NOpType_str(NOpType t) {
  switch (t) {
  case N_LT:  return "<";
  case N_GT:  return ">";
  case N_EQ:  return "==";
  case N_NEQ: return "!=";
  case N_GTE: return ">=";
  case N_LTE: return "<=";
  case N_NOT: return "!";
  case N_AND: return "&&";
  case N_OR:  return "||";
  case N_ADD: return "+";
  case N_SUB: return "-";
  case N_MUL: return "*";
  case N_DIV: return "/";
  case N_SL: return "<<";
  case N_SR: return ">>";
  case N_BA: return "&";
  case N_BO: return "|";
  case N_BN: return "~";
  case N_BX: return "^";
  default:    return "<type string undeclared>";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x12, %esi
ja 0xbd81
movl %esi, %eax
leaq 0x2ef2(%rip), %rcx      # 0xebb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30c7(%rip), %rsi      # 0xed95
jmp 0xbd88
leaq 0x30b0(%rip), %rsi      # 0xed8a
jmp 0xbd88
leaq 0x30b1(%rip), %rsi      # 0xed97
jmp 0xbd88
leaq 0x309e(%rip), %rsi      # 0xed90
jmp 0xbd88
leaq 0x3080(%rip), %rsi      # 0xed7e
jmp 0xbd88
leaq 0x3088(%rip), %rsi      # 0xed92
jmp 0xbd88
leaq 0x3079(%rip), %rsi      # 0xed8c
jmp 0xbd88
leaq 0x305c(%rip), %rsi      # 0xed78
jmp 0xbd88
leaq 0x3062(%rip), %rsi      # 0xed87
jmp 0xbd88
leaq 0x304d(%rip), %rsi      # 0xed7b
jmp 0xbd88
leaq 0x3052(%rip), %rsi      # 0xed89
jmp 0xbd88
leaq 0x3058(%rip), %rsi      # 0xed98
jmp 0xbd88
leaq 0x3053(%rip), %rsi      # 0xed9c
jmp 0xbd88
leaq 0x302f(%rip), %rsi      # 0xed81
jmp 0xbd88
leaq 0x3039(%rip), %rsi      # 0xed94
jmp 0xbd88
leaq 0x3020(%rip), %rsi      # 0xed84
jmp 0xbd88
leaq 0x302d(%rip), %rsi      # 0xed9a
jmp 0xbd88
leaq 0x3018(%rip), %rsi      # 0xed8e
jmp 0xbd88
leaq 0x3007(%rip), %rsi      # 0xed86
jmp 0xbd88
leaq 0x3016(%rip), %rsi      # 0xed9e
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x50e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NAssignment::addToRootStmts()
virtual void addToRootStmts() {
    // We want it in both lists!
    NStatement::addToRootStmts();

    extern std::vector<NAssignment*> rootAssignStmts;
    rootAssignStmts.push_back(this);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8830
leaq -0x10(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0x83d6(%rip), %rdi      # 0x14250
callq 0xc1f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r15
movq 0x810d(%rip), %rdi      # 0x13fc8
leaq 0x2d85(%rip), %rsi      # 0xec47
callq 0x51e0
movq %rax, %r12
movq (%r15), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5220
addq $0x10, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x51c0
leaq 0x283f(%rip), %rsi      # 0xe744
movq %rax, %rdi
callq 0x51e0
leaq -0x48(%rbp), %rdi
callq 0x5120
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x80a2(%rip), %rdi      # 0x13fc8
leaq 0x2831(%rip), %rsi      # 0xe75e
callq 0x51e0
movq %rax, %rdi
callq 0x5130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NFunctionDeclStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);

    if (level == 0) {
      cout << type->cpp_type_string() << ' ' << id->name << '(';
      if (args) args->generate();
      cout << ")";
    } else {
      // Lambdas don't capture by reference, by default.
      cout << "auto " << id->name << " = [] (";
      if (args) args->generate();
      cout << ")";
      if (! type->isVoid()) {
        cout << " -> " << type->cpp_type_string() << ' ';
      }
    }

    cout << " {\n";
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}";
    if (level > 0) cout << ';'; // For lambdas
    cout << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
testl %ebx, %ebx
je 0xc02c
movq 0x8042(%rip), %rdi      # 0x13fc8
leaq 0x2e2a(%rip), %rsi      # 0xedb7
callq 0x51e0
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x51c0
leaq 0x2e14(%rip), %rsi      # 0xedbd
movq %rax, %rdi
callq 0x51e0
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xbfc0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8001(%rip), %rdi      # 0x13fc8
leaq 0x2762(%rip), %rsi      # 0xe730
callq 0x51e0
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0xc09c
movq 0x7fdc(%rip), %rdi      # 0x13fc8
leaq 0x2dd2(%rip), %rsi      # 0xedc5
callq 0x51e0
movq %rax, %r15
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq *(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x51c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5220
leaq -0x40(%rbp), %rdi
callq 0x5120
jmp 0xc09c
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq *(%rax)
movq 0x7f85(%rip), %rdi      # 0x13fc8
movq %r15, %rsi
callq 0x51c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5220
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x51c0
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x5220
leaq -0x40(%rbp), %rdi
callq 0x5120
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xc089
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x7f38(%rip), %rdi      # 0x13fc8
leaq 0x2699(%rip), %rsi      # 0xe730
callq 0x51e0
movq 0x7f25(%rip), %r15      # 0x13fc8
leaq 0x230d(%rip), %rsi      # 0xe3b7
movq %r15, %rdi
callq 0x51e0
movq 0x28(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
leaq 0x2368(%rip), %rsi      # 0xe437
movq %r15, %rdi
callq 0x51e0
testl %ebx, %ebx
jle 0xc0ea
movq 0x7ee6(%rip), %rdi      # 0x13fc8
pushq $0x3b
popq %rsi
callq 0x5220
movq 0x7ed7(%rip), %rdi      # 0x13fc8
callq 0x5130
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc105
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8852
movq 0x7e77(%rip), %rdi      # 0x13fc8
leaq 0x2c72(%rip), %rsi      # 0xedca
callq 0x51e0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc16c
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x7e55(%rip), %rdi      # 0x13fc8
pushq $0x3b
popq %rsi
callq 0x5220
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
movq 0x7df0(%rip), %rdi      # 0x13fc8
leaq 0x2258(%rip), %rsi      # 0xe437
callq 0x51e0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5130
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/many_planets/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "HD10180.kms.rv";

    load(datafile, "kms", 1);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x43905(%rip), %r14     # 0x646c0
leaq 0x2625b(%rip), %rsi     # 0x4701d
movq %r14, %rdi
callq 0x6770
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x1b704(%rip), %rsi     # 0x3c4e0
movq %r14, %rdi
callq 0x2100f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x210b8
pushq $0x32
popq %rsi
movq %r14, %rdi
callq 0x21104
leaq 0x8(%rsp), %rdi
callq 0x212ca
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212ca
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x2c(%rbp), %r12
movss %xmm0, (%r12)
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x331a
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x3330
cmpq $0x5, %r13
jb 0x3220
movq %r15, %rdi
callq 0x335e
movl 0x8(%rbx), %eax
movl %eax, 0xc(%rbx)
movl 0x10(%rbx), %eax
movl %eax, 0x14(%rbx)
movl %r14d, 0x10(%rbx)
movss (%rbx), %xmm0
xorl %eax, %eax
ucomiss 0x4(%rbx), %xmm0
setbe %al
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x331a
cmpq $0x4, %rax
jae 0x32b4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %rbx
pushq $0x1
popq %r12
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x3315
leaq 0x1(%r14), %r13
movq %r12, %r15
cmpq $0x5, %r15
je 0x330d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37cc
movss (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37cc
movaps -0x40(%rbp), %xmm0
subss (%rax), %xmm0
andps 0xe31(%rip), %xmm0      # 0x4130
incq %r15
ucomiss 0xe37(%rip), %xmm0      # 0x4140
jbe 0x32cc
jmp 0x32a3
incq %r12
movq %r13, %r14
jmp 0x32bf
movb $0x1, %al
jmp 0x32a5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl %edi, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x15113
movq %rax, %rbx
movq 0x30(%rax), %rax
cmpq 0x10(%rbx), %rax
je 0x150f4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x15388
jmp 0x150fc
pushq $0x1
popq %rdi
callq 0x151b1
movq %rbx, %rdi
callq 0x16516
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x16e20
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x17e80
movq %rax, %rbx
movq %rax, %rdi
callq 0x16434
movslq %ebp, %r13
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
cmpq %r13, %rbp
jge 0x15175
movq (%r14,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x16450
movq %rbx, %rdi
movq %r15, %rsi
callq 0x168ec
movq %r15, %rdi
callq 0x86830
incq %rbp
jmp 0x15149
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x16e20
jmp 0x151a9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x86830
jmp 0x151a9
movq %rax, %r14
movq %r14, %rdi
callq 0xb7920
// File: /workspace/github_cpp_makefile_star2_O2/64Mega[P]todo-cli/src/todo.cpp
// Function: read_todos(bool)
void read_todos(bool local_mode) {
    auto buffer = get_todos(local_mode);
    if(buffer.size() == 0) {
        ccout << "Nothing to do!" << std::endl;
        return;
    }
    for(int i = 0; i < buffer.size(); i++) {
        std::string todo = buffer[i];
        if(todo.length() < 2) { continue; }
        std::replace(todo.begin(), todo.end(), '\n', ' ');
        std::replace(todo.begin(), todo.end(), '\r', ' ');
        char state = todo[0];
        todo = todo.substr(2);

        ccout << "[" << i << "] ";
        ccout << (state == 'X' ? GLYPH_INCOMPLETE : GLYPH_COMPLETE) << "\t";
        ccout << todo.c_str() << std::endl; 
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edi, %esi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x15cda
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
cmpq %rsi, %rax
je 0x1532c
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
leaq 0xe1273(%rip), %rbp     # 0xf6460
xorl %r12d, %r12d
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x15347
addq %r13, %rsi
movq %rbx, %rdi
callq 0x88fc0
movq 0x18(%rsp), %rsi
cmpq $0x2, %rsi
jb 0x1530e
movq %rbp, %r14
movq 0x10(%rsp), %rdi
addq %rdi, %rsi
movb $0xa, 0x48(%rsp)
movb $0x20, %al
movb %al, 0xf(%rsp)
movq %rbx, %r15
leaq 0x48(%rsp), %rbx
movq %rbx, %rdx
leaq 0xf(%rsp), %rbp
movq %rbp, %rcx
callq 0x164ad
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq %rdi, %rsi
movb $0xd, 0x48(%rsp)
movb $0x20, %al
movb %al, 0xf(%rsp)
movq %rbx, %rdx
movq %rbp, %rcx
movq %rbx, %rbp
movq %r15, %rbx
callq 0x164ad
movq 0x10(%rsp), %rax
movb (%rax), %r15b
movq %rbp, %rdi
movq %rbx, %rsi
pushq $0x2
popq %rdx
pushq $-0x1
popq %rcx
callq 0x891e0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x86880
movq %rbp, %rdi
callq 0x86830
movq %r14, %rbp
movq %r14, %rdi
leaq 0xa4fec(%rip), %rsi     # 0xba296
callq 0x80460
movq %rax, %rdi
movl %r12d, %esi
callq 0x80800
movq %rax, %rdi
leaq 0xa8e53(%rip), %rsi     # 0xbe117
callq 0x80460
cmpb $0x58, %r15b
leaq 0xe00dc(%rip), %rax     # 0xf53b0
leaq 0xe00dd(%rip), %rcx     # 0xf53b8
cmoveq %rcx, %rax
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x80460
movq %rax, %rdi
leaq 0xa4fa4(%rip), %rsi     # 0xba298
callq 0x80460
movq 0x10(%rsp), %rsi
movq %rbp, %rdi
callq 0x80460
movq %rax, %rdi
callq 0x7fd40
movq %rbx, %rdi
callq 0x86830
incq %r12
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
addq $0x20, %r13
jmp 0x151f0
leaq 0xe112d(%rip), %rdi     # 0xf6460
leaq 0xa4f4d(%rip), %rsi     # 0xba287
callq 0x80460
movq %rax, %rdi
callq 0x7fd40
leaq 0x30(%rsp), %rdi
callq 0x1648c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15364
jmp 0x15369
movq %rax, %rbx
jmp 0x15376
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x86830
leaq 0x30(%rsp), %rdi
callq 0x1648c
movq %rbx, %rdi
callq 0xb7920