LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9996(%rip), %r15      # 0x14fc8
leaq 0x4430(%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 0x4416(%rip), %rsi      # 0xfa73
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
cmpq $0x0, 0x8(%r14)
je 0xb680
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%r14), %r14
jmp 0xb698
leaq -0x21(%rbp), %rsi
movb $0x30, (%rsi)
movq 0x993a(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x9929(%rip), %r12      # 0x14fc8
leaq 0x43d1(%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 0x43ad(%rip), %rsi      # 0xfa7a
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x4394(%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 0x4373(%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 0x4349(%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_O1/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 0xb9d5
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 0xb9e2
callq 0x51b0
jmp 0xb9e2
cmpq $0x0, 0x8
je 0xb9a8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x95b0(%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 0xba76
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 0xba98
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc021
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %rax, %r12
movq 0x8fa0(%rip), %r14      # 0x14fc8
leaq 0x3c18(%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 0x36bd(%rip), %rsi      # 0xf744
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0a6
callq 0x51b0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x36a8(%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 0xc10e
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d62(%rip), %rax      # 0x13f48
movq %rax, (%rdi)
leaq 0x90e8(%rip), %rax      # 0x152d8
movq (%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x89ca(%rip), %rax      # 0x14bc8
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x90d4(%rip), %r12      # 0x152e0
cmpq $0x0, (%r12)
je 0xc2ab
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc22c
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, %r14
jmp 0xc243
movl $0x8, %edi
callq 0x51d0
movq %rax, %r14
leaq 0x7fc0(%rip), %rax      # 0x14200
movq %rax, (%r14)
movq (%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xc274
movq (%r12), %rdi
movq 0x20(%rdi), %rax
movq %r14, 0x20(%rax)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
jmp 0xc298
testq %rbx, %rbx
jne 0xc28b
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testb %al, %al
je 0xc2dd
testq %rbx, %rbx
je 0xc2a2
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
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x398e(%rip), %rsi      # 0xfc4d
movq %rax, %rdi
callq 0x50e0
movq 0x8d22(%rip), %rsi      # 0x14ff0
movq 0x8ceb(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x3981(%rip), %rsi      # 0xfc72
movq %rax, %rdi
callq 0x50e0
jmp 0xc2c7
jmp 0xc2fd
movq %rax, %r14
movq %rbx, %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x893a(%rip), %rax      # 0x14c68
movq %rax, (%rdi)
leaq 0x8fa0(%rip), %rax      # 0x152d8
movq (%rax), %r15
movq %r15, 0x8(%rdi)
leaq 0x88a2(%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 0xa1d6
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xc38c
callq 0x51b0
addq $0x10, %rbx
testq %r15, %r15
je 0xc3c4
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testb %al, %al
je 0xc40e
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0xc456
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 0x38c3(%rip), %rdx      # 0xfc9b
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xd474
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8bf3(%rip), %rsi      # 0x14ff0
movq 0x8bbc(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
jmp 0xc456
movl $0x10, %edi
callq 0x5120
movq %rax, %r14
leaq 0x3890(%rip), %rdx      # 0xfcb2
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xd474
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8ba9(%rip), %rsi      # 0x14ff0
movq 0x8b72(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
movl $0x10, %edi
callq 0x5120
movq %rax, %r14
leaq 0x3866(%rip), %rsi      # 0xfcd0
movq %rax, %rdi
callq 0x50e0
movq 0x8b77(%rip), %rsi      # 0x14ff0
movq 0x8b40(%rip), %rdx      # 0x14fc0
movq %r14, %rdi
callq 0x5320
movq %rax, %rbx
jmp 0xc4b3
jmp 0xc491
jmp 0xc4a8
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc4ae
callq 0x51b0
jmp 0xc4ae
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0xc4ce
movq %r14, %rdi
callq 0x5170
jmp 0xc4ce
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xc4ce
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa1d6
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc52c
callq 0x51b0
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
je 0xc54e
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 0x3774(%rip), %rdx      # 0xfcde
leaq -0x60(%rbp), %rdi
callq 0xd474
movb $0x1, %r15b
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8a64(%rip), %rsi      # 0x14ff0
movq 0x8a2d(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b8
callq 0x51b0
jmp 0xc5b8
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xc5d8
movq %rbx, %rdi
callq 0x5170
jmp 0xc5d8
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc5d8
callq 0x51b0
movq %r14, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc95c
movl %esi, %r14d
movq 0x8688(%rip), %r15      # 0x14fc8
leaq 0x2a93(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r14d
jne 0xc947
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 0xa1d6
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc9a0
callq 0x51b0
cmpb $0x0, 0x10(%r14)
jne 0xc9fd
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 0x85fb(%rip), %rdi      # 0x14fc8
callq 0x5220
leaq 0x2a02(%rip), %rsi      # 0xf3db
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc9f8
callq 0x51b0
movb $0x1, 0x10(%r14)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x85ba(%rip), %r14      # 0x14fc8
leaq 0x305e(%rip), %rsi      # 0xfa73
movl $0x3, %edx
movq %r14, %rdi
callq 0x5220
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x32de(%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 0xca92
jmp 0xca97
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xca97
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0xa1d6
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xcc63
callq 0x51b0
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
testb %al, %al
je 0xcc87
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
jmp 0xccf8
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)
movq -0x40(%rbp), %rdx
movb $0x1, %bl
cmpq -0x60(%rbp), %rdx
jne 0xcccf
testq %rdx, %rdx
je 0xcccd
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x51e0
testl %eax, %eax
setne %bl
jmp 0xcccf
xorl %ebx, %ebx
leaq -0x58(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xcce2
callq 0x51b0
leaq -0x38(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xccf4
callq 0x51b0
testb %bl, %bl
jne 0xcd0a
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r14
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x3006(%rip), %rdx      # 0xfd28
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0xd474
movq 0x8(%r15), %rsi
movq (%rsi), %rax
leaq -0xa8(%rbp), %rdi
callq *(%rax)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0xd4ce
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x8285(%rip), %rsi      # 0x14ff0
movq 0x824e(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xcd93
callq 0x51b0
jmp 0xcd93
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcdb0
callq 0x51b0
jmp 0xcdb0
movq %rax, %r14
movb $0x1, %r15b
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xcdc6
callq 0x51b0
jmp 0xcdc6
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xcdfb
movq %rbx, %rdi
callq 0x5170
jmp 0xcdfb
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xcdf6
jmp 0xcdfb
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xcdfb
callq 0x51b0
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xa1d6
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
movq %rax, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xcee8
callq 0x51b0
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
testb %al, %al
je 0xcf07
movq 0x18(%r14), %rdx
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
jmp 0xcf12
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbfe8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xcf32
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x12, %esi
ja 0xd454
movl %esi, %eax
leaq 0x28b6(%rip), %rcx      # 0xfbb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2a8b(%rip), %rsi      # 0xfd95
leaq 0x2a85(%rip), %rdx      # 0xfd96
jmp 0xd462
leaq 0x2a6d(%rip), %rsi      # 0xfd8a
leaq 0x2a67(%rip), %rdx      # 0xfd8b
jmp 0xd462
leaq 0x2a67(%rip), %rsi      # 0xfd97
leaq 0x2a62(%rip), %rdx      # 0xfd99
jmp 0xd462
leaq 0x2a4d(%rip), %rsi      # 0xfd90
leaq 0x2a47(%rip), %rdx      # 0xfd91
jmp 0xd462
leaq 0x2a28(%rip), %rsi      # 0xfd7e
leaq 0x2a23(%rip), %rdx      # 0xfd80
jmp 0xd462
leaq 0x2a29(%rip), %rsi      # 0xfd92
leaq 0x2a23(%rip), %rdx      # 0xfd93
jmp 0xd462
leaq 0x2a10(%rip), %rsi      # 0xfd8c
leaq 0x2a0a(%rip), %rdx      # 0xfd8d
jmp 0xd462
leaq 0x29e9(%rip), %rsi      # 0xfd78
leaq 0x29e4(%rip), %rdx      # 0xfd7a
jmp 0xd462
leaq 0x29e5(%rip), %rsi      # 0xfd87
leaq 0x29df(%rip), %rdx      # 0xfd88
jmp 0xd462
leaq 0x29c6(%rip), %rsi      # 0xfd7b
leaq 0x29c1(%rip), %rdx      # 0xfd7d
jmp 0xd462
leaq 0x29c1(%rip), %rsi      # 0xfd89
leaq 0x29bc(%rip), %rdx      # 0xfd8b
jmp 0xd462
leaq 0x29bd(%rip), %rsi      # 0xfd98
leaq 0x29b7(%rip), %rdx      # 0xfd99
jmp 0xd462
leaq 0x29b1(%rip), %rsi      # 0xfd9c
leaq 0x29ab(%rip), %rdx      # 0xfd9d
jmp 0xd462
leaq 0x2986(%rip), %rsi      # 0xfd81
leaq 0x2981(%rip), %rdx      # 0xfd83
jmp 0xd462
leaq 0x2989(%rip), %rsi      # 0xfd94
leaq 0x2984(%rip), %rdx      # 0xfd96
jmp 0xd462
leaq 0x2969(%rip), %rsi      # 0xfd84
leaq 0x2963(%rip), %rdx      # 0xfd85
jmp 0xd462
leaq 0x296f(%rip), %rsi      # 0xfd9a
leaq 0x2969(%rip), %rdx      # 0xfd9b
jmp 0xd462
leaq 0x2953(%rip), %rsi      # 0xfd8e
leaq 0x294d(%rip), %rdx      # 0xfd8f
jmp 0xd462
leaq 0x293b(%rip), %rsi      # 0xfd86
leaq 0x2936(%rip), %rdx      # 0xfd88
jmp 0xd462
leaq 0x2943(%rip), %rsi      # 0xfd9e
leaq 0x2954(%rip), %rdx      # 0xfdb6
movq %rbx, %rdi
callq 0xa13c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8fdc
movq %rbx, -0x10(%rbp)
leaq 0x7c7d(%rip), %rax      # 0x15230
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0xd5c7
movq %rbx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0xd5d7
leaq 0x7c62(%rip), %rdi      # 0x15230
leaq -0x10(%rbp), %rdx
callq 0xdb84
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r12
movq 0x79b5(%rip), %rbx      # 0x14fc8
leaq 0x262d(%rip), %rsi      # 0xfc47
movl $0x5, %edx
movq %rbx, %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 %rbx, %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 0x20d2(%rip), %rsi      # 0xf744
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd691
callq 0x51b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x20bd(%rip), %rsi      # 0xf75e
movl $0x3, %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
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 0xd6f9
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0xda2e
movl %esi, %r14d
movq 0x75b6(%rip), %r15      # 0x14fc8
leaq 0x19c1(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r14d
jne 0xda19
movq 0x7593(%rip), %rdi      # 0x14fc8
leaq 0x238e(%rip), %rsi      # 0xfdca
movl $0x7, %edx
callq 0x5220
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xda55
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x21(%rbp), %rsi
movb $0x3b, (%rsi)
movq 0x7565(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq %rax, %rbx
movq (%rax), %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
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xdae1
movq 0x7506(%rip), %r15      # 0x14fc8
leaq 0x1911(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0xdacc
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)
testl %ebx, %ebx
jle 0xdb33
movq 0x74b0(%rip), %r14      # 0x14fc8
leaq 0x18bb(%rip), %r15      # 0xf3da
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5220
decl %ebx
jne 0xdb1f
movq 0x748e(%rip), %rbx      # 0x14fc8
leaq 0x18f6(%rip), %rsi      # 0xf437
movl $0x1, %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 %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x32853(%rip), %rdx     # 0x53548
leaq 0x32844(%rip), %r14     # 0x53540
leaq 0x2468e(%rip), %rcx     # 0x45391
movl $0xe, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x1e7c3(%rip), %rsi     # 0x3f4e8
movq %r14, %rdi
callq 0x20f1d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21020
movq %r14, %rdi
movl $0x32, %esi
callq 0x210f2
leaq 0x8(%rsp), %rdi
callq 0x212d0
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212d0
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movss %xmm0, -0x1c(%rbp)
movq 0x60(%rdi), %rax
movq %rax, %rcx
subq 0x40(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq 0x18(%rdi), %r15
shlq $0x7, %rcx
movq 0x38(%rdi), %rdx
movq 0x48(%rdi), %rax
movq %rax, %rsi
subq 0x50(%rdi), %rsi
sarq $0x2, %rsi
subq 0x28(%rdi), %rdx
sarq $0x2, %rdx
addq %rsi, %rdx
addq %rcx, %rdx
movq 0x58(%rdi), %rcx
addq $-0x4, %rcx
cmpq $0x4, %rdx
ja 0x3602
cmpq %rcx, %rax
je 0x3615
movss %xmm0, (%rax)
addq $0x4, %rax
movq %rax, 0x48(%rbx)
jmp 0x3637
cmpq %rcx, %rax
je 0x3623
movss %xmm0, (%rax)
addq $0x4, %rax
movq %rax, 0x48(%rbx)
jmp 0x362f
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3a14
jmp 0x3637
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3a14
movq %r15, %rdi
callq 0x3846
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 %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x60(%rdi), %rax
movq 0x40(%rdi), %rcx
movq %rax, %rsi
subq %rcx, %rsi
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
shlq $0x7, %rsi
movq 0x48(%rdi), %rax
subq 0x50(%rdi), %rax
sarq $0x2, %rax
movq 0x28(%rdi), %rdx
movq 0x38(%rdi), %r8
subq %rdx, %r8
sarq $0x2, %r8
addq %rax, %r8
addq %rsi, %r8
cmpq $0x4, %r8
jae 0x36f0
movl $0x0, -0x2c(%rbp)
jmp 0x3836
movq %rdx, %rax
subq 0x30(%rdi), %rax
movq %rax, %r15
sarq $0x2, %r15
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movl $0x1, %eax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movaps 0xa42(%rip), %xmm0      # 0x4160
movss 0xa4a(%rip), %xmm1      # 0x4170
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %r8
leaq 0x1(%r8), %rax
movq %rax, -0x38(%rbp)
leaq (%r15,%r8), %rbx
movq %rbx, %rax
shrq $0x7, %rax
movq %rax, %r14
movabsq $-0x200000000000000, %rsi # imm = 0xFE00000000000000
orq %rsi, %r14
testq %rbx, %rbx
cmovgq %rax, %r14
movq %r14, %rax
shlq $0x7, %rax
movq %rbx, %rsi
subq %rax, %rsi
movq %r8, -0x50(%rbp)
leaq (%rdx,%r8,4), %rax
xorl %r13d, %r13d
shlq $0x2, %rsi
movq %rsi, -0x58(%rbp)
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %r9
movq %rax, %r12
cmpq $0x80, %rbx
jb 0x3797
movq (%rcx,%r14,8), %r12
addq -0x58(%rbp), %r12
leaq (%r15,%r9), %r11
cmpq $0x7f, %r11
ja 0x37a7
leaq (%rdx,%r9,4), %r11
jmp 0x37df
movq %r11, %rsi
shrq $0x7, %rsi
movq %rsi, %r10
movq %rcx, %rdi
movq %rdx, %rcx
movabsq $-0x200000000000000, %rdx # imm = 0xFE00000000000000
orq %rdx, %r10
movq %rcx, %rdx
movq %rdi, %rcx
testq %r11, %r11
cmovgq %rsi, %r10
movq (%rdi,%r10,8), %r11
shlq $0x9, %r10
subq %r10, %r11
addq %r8, %r11
movss (%r12), %xmm2
subss (%r11), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm1, %xmm2
ja 0x3811
cmpq $0x4, %r9
leaq 0x1(%r9), %r11
setae %r13b
addq $0x4, %r8
movq %r11, %r9
cmpq $0x5, %r11
jne 0x3783
jmp 0x3817
testb $0x1, %r13b
je 0x3836
cmpq $0x3, -0x50(%rbp)
setae %al
movl %eax, -0x2c(%rbp)
incq -0x40(%rbp)
addq $0x4, -0x48(%rbp)
cmpq $0x4, -0x38(%rbp)
jne 0x372d
movl -0x2c(%rbp), %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15169
movq %rax, %rbx
movq 0x30(%rax), %rax
cmpq 0x10(%rbx), %rax
je 0x15146
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15505
jmp 0x15150
movl $0x1, %edi
callq 0x15249
movq %rbx, %rdi
callq 0x16e50
movl $0x50, %esi
movq %rbx, %rdi
callq 0x17920
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x50, %edi
callq 0x18980
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x170c8
cmpl $0x2, %ebp
jl 0x151fe
movl %ebp, %ebp
movl $0x1, %r13d
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x16d2c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x172ec
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x151f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17920
incq %r13
cmpq %r13, %rbp
jne 0x151c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
jmp 0x1523c
movq %rax, %r14
jmp 0x15241
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15241
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17920
movq %r14, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: match_one_or_more(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool match_one_or_more(std::string input, std::string compare) {
    if(input.length() > 0 && compare.length() > 0) {
        std::string command = compare;
        if(input.length() < command.length()) {
            command = command.substr(0, input.length());
        }

        return input.compare(command) == 0;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x16216
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x16216
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17038
movq 0x8(%rbx), %rcx
cmpq 0x8(%r14), %rcx
jae 0x161ee
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x89c10
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x87380
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x161ee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x17920
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x89390
testl %eax, %eax
sete %bl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x16218
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x17920
jmp 0x16218
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16226
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1623f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x17920
movq %rbx, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: todo_init(bool)
void todo_init(bool is_local) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(is_local) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "w");
    if(fp) {
        ccout << "Created " << path << std::endl;
        fclose(fp);
    } else {
        ccout << "Error creating " << path << std::endl;
    }    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edi, %ebx
leaq 0xa4ff8(%rip), %rdi     # 0xbb254
callq 0x124b0
testl %ebx, %ebx
je 0x1627f
leaq 0xa4fed(%rip), %rsi     # 0xbb259
leaq 0xa4fef(%rip), %rdx     # 0xbb262
movq %rsp, %rdi
xorl %eax, %eax
callq 0x12370
jmp 0x1629a
leaq 0xa4fde(%rip), %rsi     # 0xbb264
leaq 0xa4fd5(%rip), %rcx     # 0xbb262
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12370
leaq 0xa8e35(%rip), %rsi     # 0xbf0d6
movq %rsp, %rdi
callq 0x121f0
testq %rax, %rax
je 0x16316
movq %rax, %rbx
leaq 0xe11a8(%rip), %r14     # 0xf7460
leaq 0xa4faf(%rip), %rsi     # 0xbb26e
movl $0x8, %edx
movq %r14, %rdi
callq 0x80a30
movq %rsp, %r15
movq %r15, %rdi
callq 0x122f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %r14, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %rbx, %rdi
callq 0x12580
jmp 0x16371
leaq 0xe1143(%rip), %rbx     # 0xf7460
leaq 0xa4f53(%rip), %rsi     # 0xbb277
movl $0xf, %edx
movq %rbx, %rdi
callq 0x80a30
movq %rsp, %r14
movq %r14, %rdi
callq 0x122f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x80a30
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %rbx, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: get_todos[abi:cxx11](bool)
std::vector<std::string> get_todos(bool local_mode)  {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local_mode) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "r");
    std::vector<std::string> buffer;
    if(fp) {
        do {
            char line[PATHMAX];
            char* res = fgets(line, PATHMAX, fp);
            if(res) {
                buffer.push_back(std::string(res));
            } else {
                break;
            }
        } while(true);
        fclose(fp);
    } else {
        usage();        
    }    
    
    return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa4eb9(%rip), %rdi     # 0xbb254
callq 0x124b0
testl %ebp, %ebp
je 0x163c0
leaq 0xa4eae(%rip), %rsi     # 0xbb259
leaq 0xa4eb0(%rip), %rdx     # 0xbb262
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x12370
jmp 0x163dd
leaq 0xa4e9d(%rip), %rsi     # 0xbb264
leaq 0xa4e94(%rip), %rcx     # 0xbb262
leaq 0x20(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12370
leaq 0xa971b(%rip), %rsi     # 0xbfaff
leaq 0x20(%rsp), %rdi
callq 0x121f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x16477
movq %rax, %r14
leaq 0x10(%rsp), %rbp
leaq 0x1020(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdx
callq 0x12260
testq %rax, %rax
je 0x1646d
movq %rax, %r13
movq %rbp, (%rsp)
movq %rax, %rdi
callq 0x122f0
leaq (%rax,%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1725c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x175ba
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x16468
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x17920
testq %r13, %r13
jne 0x16414
movq %r14, %rdi
callq 0x12580
jmp 0x1647c
callq 0x16018
movq %rbx, %rax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x164ae
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x164b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x17920
jmp 0x164b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x16d6a
movq %r14, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: concat_remainder(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
std::string concat_remainder(std::queue<std::string>* command_list) {
    std::string s;
    while(!command_list->empty()) {
        s += command_list->front();
        command_list->pop();
        if(!command_list->empty()) { s += " "; }
    }

    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x10(%rsi), %rax
cmpq %rax, 0x30(%rsi)
je 0x16529
movq %rsi, %r14
leaq 0xa504d(%rip), %r15     # 0xbb540
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x889a0
movq %r14, %rdi
callq 0x17806
movq 0x30(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x1651f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88ae0
movq 0x10(%r14), %rax
cmpq %rax, 0x30(%r14)
jne 0x164f3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1654f
movq (%r12), %rsi
incq %rsi
callq 0x17920
movq %r14, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: write_todo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void write_todo(std::string msg, bool local_mode) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local_mode) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "a");
    if(fp) {
        fseek(fp, 0, SEEK_END);
        fprintf(fp, "X:%s\n", msg.c_str());
        ccout << "Added!" << std::endl;
        fclose(fp);
    } else {
        ccout << "Error adding todo." << std::endl;
    }    
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa4ce6(%rip), %rdi     # 0xbb254
callq 0x124b0
testl %ebp, %ebp
je 0x16591
leaq 0xa4cdb(%rip), %rsi     # 0xbb259
leaq 0xa4cdd(%rip), %rdx     # 0xbb262
movq %rsp, %rdi
xorl %eax, %eax
callq 0x12370
jmp 0x165ac
leaq 0xa4ccc(%rip), %rsi     # 0xbb264
leaq 0xa4cc3(%rip), %rcx     # 0xbb262
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12370
leaq 0xa8b14(%rip), %rsi     # 0xbf0c7
movq %rsp, %rdi
callq 0x121f0
testq %rax, %rax
je 0x1663b
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x12150
movq (%rbx), %rdx
leaq 0xa4cbe(%rip), %rsi     # 0xbb29a
movq %r14, %rdi
xorl %eax, %eax
callq 0x12670
leaq 0xe0e73(%rip), %rbx     # 0xf7460
leaq 0xa4cac(%rip), %rsi     # 0xbb2a0
movl $0x6, %edx
movq %rbx, %rdi
callq 0x80a30
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %rbx, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %r14, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
jmp 0x12580
leaq 0xe0e1e(%rip), %rbx     # 0xf7460
leaq 0xa4c5e(%rip), %rsi     # 0xbb2a7
movl $0x12, %edx
movq %rbx, %rdi
callq 0x80a30
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %rbx, %rdi
callq 0x80530
movq %rax, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
jmp 0x7fb00
// File: /workspace/github_cpp_makefile_star2_O1/64Mega[P]todo-cli/src/todo.cpp
// Function: rewrite_todos(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool)
void rewrite_todos(std::vector<std::string> buffer, bool local) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "w");
    if(fp) {
        for(int i = 0; i < buffer.size(); i++) {
            // This guard here skips any blank lines. This is a little 'cheat' to allow for
            // easier deletion. Just set the respective line to be blank, and it'll be 'skipped' 
            // during output.
            if(buffer[i].length() == 0) { continue; }
            fprintf(fp, "%s", buffer[i].c_str());
        }        
        fclose(fp);        
    } else {
        ccout << "Error updating todos." << std::endl;
    }    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa4bb1(%rip), %rdi     # 0xbb254
callq 0x124b0
testl %ebp, %ebp
je 0x166c6
leaq 0xa4ba6(%rip), %rsi     # 0xbb259
leaq 0xa4ba8(%rip), %rdx     # 0xbb262
movq %rsp, %rdi
xorl %eax, %eax
callq 0x12370
jmp 0x166e1
leaq 0xa4b97(%rip), %rsi     # 0xbb264
leaq 0xa4b8e(%rip), %rcx     # 0xbb262
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12370
leaq 0xa89ee(%rip), %rsi     # 0xbf0d6
movq %rsp, %rdi
callq 0x121f0
testq %rax, %rax
je 0x1674f
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x16738
movl $0x8, %r15d
xorl %r12d, %r12d
cmpq $0x0, (%rax,%r15)
je 0x1671e
movq -0x8(%rax,%r15), %rdi
movq %r14, %rsi
callq 0x12400
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x1670a
movq %r14, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12580
leaq 0xe0d0a(%rip), %rbx     # 0xf7460
leaq 0xa4b5d(%rip), %rsi     # 0xbb2ba
movl $0x15, %edx
movq %rbx, %rdi
callq 0x80a30
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %rbx, %rdi
callq 0x80530
movq %rax, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7fb00