LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/eval.cpp
// Function: AST_Handler::next()
Node AST_Handler::next() 
{
    ptr++;
    if (ptr >= (int) ast.nodes.size()) 
    {
        eof = true;
    }
    return ast.nodes.at(ptr-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movl 0x70(%rsi), %esi
leal 0x1(%rsi), %ecx
movl %ecx, 0x70(%rax)
movq (%rax), %r13
movq 0x8(%rax), %rdi
subq %r13, %rdi
sarq $0x4, %rdi
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
cmpl %edx, %ecx
jb 0x4cd8
movb $0x1, 0x74(%rax)
cmpq %rsi, %rdx
jbe 0x4d69
imulq $0x70, %rsi, %r14
leaq (%r14,%r13), %r12
addq $0x8, %r12
movl -0x8(%r12), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r12, %rsi
callq 0xe02a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rbx)
movq 0x18(%r12), %rsi
movq 0x20(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x367e
addq %r14, %r13
movq 0x40(%r13), %rax
movq %rax, 0x40(%rbx)
movl 0x48(%r13), %eax
movl %eax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq 0x50(%r13), %rsi
movq 0x58(%r13), %rdx
addq %rsi, %rdx
callq 0x367e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xef7f(%rip), %rdi      # 0x13cef
xorl %eax, %eax
callq 0x2320
movq %rax, %rbx
movq (%r15), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4d97
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
jmp 0x4d97
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0xe0cc
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_add_nums[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_add_nums(std::vector<object> objs) 
{
    double res = to_number(objs.at(0).value);
    for (int i = 1; i < (int)objs.size(); i++) 
    {
        res += to_number(objs.at(i).value);
    }
    return std::to_string(res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x5225
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x367e
movq %r15, %rdi
callq 0x11e64
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x5135
movq -0x70(%rbp), %rsi
incq %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2240
movsd -0x30(%rbp), %xmm0
movq %rbx, -0x38(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpl $0x2, %edx
jl 0x51e1
movl $0x1, %r15d
movl $0x50, %ebx
leaq -0x50(%rbp), %r13
leaq -0x60(%rbp), %r12
movsd %xmm0, -0x30(%rbp)
cmpq %r15, %rdx
jbe 0x5214
movq %r13, -0x60(%rbp)
movq -0x8(%rax,%rbx), %rsi
movq (%rax,%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x367e
movq %r12, %rdi
callq 0x11e64
movapd %xmm0, %xmm1
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x51b4
movq -0x50(%rbp), %rsi
incq %rsi
movsd %xmm1, -0x40(%rbp)
callq 0x2240
movsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x6, %rdx
shrq $0x6, %rcx
movslq %ecx, %rcx
addq $0x40, %rbx
cmpq %rcx, %r15
jl 0x5163
movq 0x13dd0(%rip), %rsi     # 0x18fb8
leaq 0xeafd(%rip), %rcx      # 0x13cec
movl $0x148, %edx            # imm = 0x148
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0xe305
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xead4(%rip), %rdi      # 0x13cef
movq %r15, %rsi
xorl %eax, %eax
callq 0x2320
leaq 0xeac3(%rip), %rdi      # 0x13cef
xorl %esi, %esi
xorl %edx, %edx
jmp 0x521e
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x5242
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5253
movq (%r13), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_div_nums[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_div_nums(std::vector<object> objs) 
{
    double res = to_number(objs.at(0).value);
    for (int i = 1; i < (int)objs.size(); i++) 
    {
        res /= to_number(objs.at(i).value);
    }
    return std::to_string(res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x56d5
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x367e
movq %r15, %rdi
callq 0x11e64
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x55e5
movq -0x70(%rbp), %rsi
incq %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2240
movsd -0x30(%rbp), %xmm0
movq %rbx, -0x38(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpl $0x2, %edx
jl 0x5691
movl $0x1, %r15d
movl $0x50, %ebx
leaq -0x50(%rbp), %r13
leaq -0x60(%rbp), %r12
movsd %xmm0, -0x30(%rbp)
cmpq %r15, %rdx
jbe 0x56c4
movq %r13, -0x60(%rbp)
movq -0x8(%rax,%rbx), %rsi
movq (%rax,%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x367e
movq %r12, %rdi
callq 0x11e64
movapd %xmm0, %xmm1
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5664
movq -0x50(%rbp), %rsi
incq %rsi
movsd %xmm1, -0x40(%rbp)
callq 0x2240
movsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x6, %rdx
shrq $0x6, %rcx
movslq %ecx, %rcx
addq $0x40, %rbx
cmpq %rcx, %r15
jl 0x5613
movq 0x13920(%rip), %rsi     # 0x18fb8
leaq 0xe64d(%rip), %rcx      # 0x13cec
movl $0x148, %edx            # imm = 0x148
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0xe305
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe624(%rip), %rdi      # 0x13cef
movq %r15, %rsi
xorl %eax, %eax
callq 0x2320
leaq 0xe613(%rip), %rdi      # 0x13cef
xorl %esi, %esi
xorl %edx, %edx
jmp 0x56ce
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x56f2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5703
movq (%r13), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Evaluator::destructive_return(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, object)
void Evaluator::destructive_return(std::string name, object value)
{
    Env top = env_stack.back();
    top.set_key(name, value);
    env_stack.pop();
    env_stack.push(top);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2b2a
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x367e
movl (%r14), %eax
leaq -0x80(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x367e
leaq -0x60(%rbp), %r15
addq $0x28, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e00
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x296c
movq %r15, %rdi
callq 0x2c20
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x57bd
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x57d2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x2b54
leaq -0xe8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x330e
leaq -0xe8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2b4a
leaq -0xe8(%rbp), %rdi
callq 0x3666
leaq -0xb8(%rbp), %rdi
callq 0x3666
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3666
jmp 0x587f
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2d8c
jmp 0x5865
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x5865
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x5865
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x587f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x587f
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3666
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/main.cpp
// Function: main
int main(int argc, char const *argv[])
{   
    if (argc <2) 
    { 
        REPL();
        return 0;
    }
    std::string code = read_ascii_file(argv[1]);
    return evalString(code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x1, %edi
jle 0xff33
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x11f88
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x367e
leaq -0x30(%rbp), %rdi
callq 0xedc5
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xff0f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xff28
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf4c1
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xff55
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0xff55
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xff6e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/parser.cpp
// Function: is_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_number(std::string value) 
{
    bool ret = false;
    bool dec_point_found = false;

    // If value is negative
    if (value.length() >= 2 and value.at(1) == '-') 
    {
        value = value.substr(1); 
    }
    for (int i = 0; i < value.length(); i++) 
    {
        char t = value.at(i);
        ret = is_num(t);
        if (t == '.') 
        {
            dec_point_found = !dec_point_found;
            ret = !ret;
        }
        if (!ret) 
        {
            break;
        }
    } 
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x2, 0x8(%rdi)
jb 0x108b1
movq (%rbx), %rax
cmpb $0x2d, 0x1(%rax)
jne 0x108b1
leaq -0x30(%rbp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x2260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x108b1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x108e5
movq (%rbx), %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %al
leal -0x30(%rax), %edi
cmpb $0xa, %dil
setb %dil
cmpb $0x2e, %al
sete %al
orb %dil, %al
cmpb $0x1, %al
jne 0x108e7
incq %rsi
cmpq %rsi, %rcx
jne 0x108bf
movb $0x1, %al
jmp 0x108e7
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/parser.cpp
// Function: Typeof(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AtomType Typeof(std::string value) 
{
    if (value.back() == '\'' and value.front() == '\'') 
    {
        return STRING;
    }
    else if (is_number(value)) 
    {
        return NUMBER;
    }
    return SYMBOL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
cmpb $0x27, -0x1(%rsi,%rdx)
jne 0x10913
movl $0x1, %eax
cmpb $0x27, (%rsi)
je 0x10951
addq %rsi, %rdx
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x367e
movq %rbx, %rdi
callq 0x10855
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x10949
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
xorb $0x1, %bl
movzbl %bl, %eax
addl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x10972
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/parser.cpp
// Function: create_atom(Token)
Atom create_atom(Token tok)  
{
    Atom atom{};
    atom.type = Typeof(tok.value);
    atom.value = tok.value;
    atom.line = tok.line;
    atom.token = tok;
    return atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x367e
leaq -0x40(%rbp), %rdi
callq 0x108f0
leaq 0x8(%r14), %r15
movl %eax, 0x24(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x109fb
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movl (%r14), %eax
movl %eax, 0x20(%rbx)
movl %eax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x2150
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x10a48
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x10a48
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd00
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/../include/parser.h
// Function: Reader::next()
Token next() 
    {
        ptr++;
        if (ptr >= (int) tokens.token_stream.size()) 
        {
            eof = true;
        }
        return tokens.token_stream.at(ptr-1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movslq 0x18(%rsi), %rsi
leal 0x1(%rsi), %edi
movl %edi, 0x18(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %r8
subq %rcx, %r8
sarq $0x3, %r8
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %r8, %rdx
cmpl %edx, %edi
jl 0x11526
movb $0x1, 0x1c(%rax)
cmpq %rsi, %rdx
jbe 0x1155c
leaq (%rsi,%rsi,4), %rax
movl (%rcx,%rax,8), %edx
movl %edx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rdx
movq %rdx, 0x8(%rbx)
movq 0x8(%rcx,%rax,8), %rsi
movq 0x10(%rcx,%rax,8), %rdx
addq %rsi, %rdx
callq 0x367e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x278c(%rip), %rdi      # 0x13cef
xorl %eax, %eax
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/types.cpp
// Function: repr[abi:cxx11](object)
std::string repr(object obj) 
{
    if (obj.type == BOP_NUMBER) 
    {
        return obj.value;
    }
    else if (obj.type == BOP_LIST) 
    {
        return "<List>";
    }
    else 
    {
        return format_string(obj.value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x11dc8
cmpl $0x1, %eax
jne 0x11de7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x367e
jmp 0x11e36
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2150(%rip), %rsi      # 0x13f26
leaq 0x214f(%rip), %rdx      # 0x13f2c
movq %rbx, %rdi
callq 0x3766
jmp 0x11e36
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x367e
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11e36
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11e5c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Mespyr[P]bop-lisp/src/types.cpp
// Function: make_object(Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<object, std::allocator<object>>)
object make_object(Type type_, std::string value, std::vector<object> list) 
{
    object obj;
    obj.type = type_;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xbbe1(%rip), %r14      # 0x14fc8
leaq 0x603d(%rip), %rsi      # 0xf42b
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x6021(%rip), %rsi      # 0xf42d
movl $0x1, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5220
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NBinaryOperator::get_type()
Type* get_type() {
    Type *lhs_type = lhs->get_type();
    Type *rhs_type;

    // Propogate the types, for implicit typing
    if (lhs_type->isUnset()) {
      rhs_type = lhs_type = rhs->get_type();
      lhs->set_type(rhs_type);
    } else {
      rhs->set_type(lhs_type);
      rhs_type = lhs_type;
    }
    return lhs_type;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rcx
testb %al, %al
je 0x94d6
callq *(%rcx)
movq %rax, %rbx
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
jmp 0x94dc
movq %rbx, %rsi
callq *0x8(%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NWhileStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "while (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x9679
movq 0xb96e(%rip), %r14      # 0x14fc8
leaq 0x5d79(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x9664
movq 0xb948(%rip), %r14      # 0x14fc8
leaq 0x5da8(%rip), %rsi      # 0xf42f
movl $0x7, %edx
movq %r14, %rdi
callq 0x5220
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x60b9(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq 0x18(%r15), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x970b
movq 0xb8d8(%rip), %r15      # 0x14fc8
leaq 0x5ce3(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %ebx
jne 0x96f7
leaq 0x5d25(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5150
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NIfStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x9791
movq 0xb856(%rip), %r15      # 0x14fc8
leaq 0x5c61(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x977c
movq 0xb830(%rip), %r15      # 0x14fc8
leaq 0x5c9f(%rip), %rsi      # 0xf43e
movl $0x4, %edx
movq %r15, %rdi
callq 0x5220
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x5fa1(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq %r14, -0x30(%rbp)
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x982b
movq 0xb7bc(%rip), %r12      # 0x14fc8
leaq 0x5bc7(%rip), %r13      # 0xf3da
movl %ebx, %r14d
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x5220
decl %r14d
jne 0x9816
leaq 0x5c05(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
jne 0x987c
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x9894
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElifStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x98e1
movq 0xb706(%rip), %r15      # 0x14fc8
leaq 0x5b11(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x98cc
movq 0xb6e0(%rip), %r15      # 0x14fc8
leaq 0x5b4a(%rip), %rsi      # 0xf439
movl $0x9, %edx
movq %r15, %rdi
callq 0x5220
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x5e51(%rip), %rsi      # 0xf75e
movl $0x3, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq %r14, -0x30(%rbp)
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x997b
movq 0xb66c(%rip), %r12      # 0x14fc8
leaq 0x5a77(%rip), %r13      # 0xf3da
movl %ebx, %r14d
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x5220
decl %r14d
jne 0x9966
leaq 0x5ab5(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r15, %rdi
callq 0x5220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
jne 0x99cc
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x99e4
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElseStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x9a31
movq 0xb5b6(%rip), %r14      # 0x14fc8
leaq 0x59c1(%rip), %r12      # 0xf3da
movl %ebx, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
decl %r13d
jne 0x9a1c
movq 0xb590(%rip), %r14      # 0x14fc8
leaq 0x5a04(%rip), %rsi      # 0xf443
movl $0x6, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5150
movq 0x10(%r15), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
testl %ebx, %ebx
jle 0x9aa5
movq 0xb53e(%rip), %r15      # 0x14fc8
leaq 0x5949(%rip), %r12      # 0xf3da
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
decl %ebx
jne 0x9a91
leaq 0x598b(%rip), %rsi      # 0xf437
movl $0x1, %edx
movq %r14, %rdi
callq 0x5220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5150
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NArgs::generate()
virtual void generate() {
    cout << get_type()->cpp_type_string() << " " << id->name;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xb152(%rip), %rdi      # 0x14fc8
callq 0x5220
movq %rax, %r14
leaq 0x5556(%rip), %rsi      # 0xf3db
movl $0x1, %edx
movq %rax, %rdi
callq 0x5220
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x5220
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9eb8
callq 0x51b0
cmpq $0x0, 0x10(%rbx)
je 0x9ee1
leaq -0x30(%rbp), %rsi
movb $0x2c, (%rsi)
movq 0xb0fb(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9eff
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NString::generate_itr_header(NIdentifier*)
virtual void generate_itr_header(NIdentifier *id) {
    cout << "for (std::string " << id->name << " : ";
    cout << "javelin::string_itr(";
    generate();
    cout << ")) {" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xaf27(%rip), %rbx      # 0x14fc8
leaq 0x568a(%rip), %rsi      # 0xf732
movl $0x11, %edx
movq %rbx, %rdi
callq 0x5220
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0x5220
leaq 0x5678(%rip), %rsi      # 0xf744
movl $0x3, %edx
movq %rax, %rdi
callq 0x5220
leaq 0x5668(%rip), %rsi      # 0xf748
movl $0x14, %edx
movq %rbx, %rdi
callq 0x5220
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x5660(%rip), %rsi      # 0xf75d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x51c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5150
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::addDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Definition*)
void Scope::addDefinition(string name, Definition *definition) {
  if (table.find(name) != table.end()) {
    throw std::runtime_error("Definition '" + name +
                             "' previously declared as a " +
                             (table[name]->isFunction() ? "fun" : "var"));
  }
  table[name] = definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0xbb40
testq %rax, %rax
jne 0xa2b8
movq %r15, %rdi
movq %r14, %rsi
callq 0xbc6c
movq %rbx, (%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x56b2(%rip), %rsi      # 0xf97e
leaq -0x88(%rbp), %rdi
movq %r14, %rdx
callq 0xab72
leaq 0x56a9(%rip), %rsi      # 0xf98b
leaq -0x88(%rbp), %rdi
callq 0x5370
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xa310
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xa31b
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xbc6c
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x565b(%rip), %rcx      # 0xf9a7
leaq 0x5658(%rip), %rsi      # 0xf9ab
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5370
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xa383
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xa38e
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0xac32(%rip), %rsi      # 0x14ff0
movq 0xabfb(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x5320
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xa3e6
callq 0x51b0
jmp 0xa3e6
movq %rax, %r14
movb $0x1, %r15b
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xa3fc
callq 0x51b0
jmp 0xa3fc
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa416
callq 0x51b0
jmp 0xa416
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xa423
movq %rbx, %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::findDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Definition * Scope::findDefinition(string name) {
  auto itr = table.find(name);
  if (itr != table.end()) {
    return (*itr).second;
  } else if (this->next != NULL) {
    return this->next->findDefinition(name);
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xbb40
testq %rax, %rax
je 0xa45f
movq 0x28(%rax), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
je 0xa4a4
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xa1d6
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa451
callq 0x51b0
jmp 0xa451
xorl %ebx, %ebx
jmp 0xa451
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa4b9
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: FunctionDefinition::argsMatch(NExpressionArgs*)
bool FunctionDefinition::argsMatch(NExpressionArgs *args) {
  NExpressionArgs *itr1 = args;
  NArgs *itr2 = stmt->args;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %r14
testq %rsi, %rsi
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa590
leaq -0x68(%rbp), %r12
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
movq (%r13), %rax
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq *(%rax)
movq (%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax)
movq -0x40(%rbp), %rdx
movb $0x1, %r15b
cmpq -0x60(%rbp), %rdx
jne 0xa551
testq %rdx, %rdx
je 0xa54e
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x51e0
testl %eax, %eax
setne %r15b
jmp 0xa551
xorl %r15d, %r15d
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xa563
callq 0x51b0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xa575
callq 0x51b0
testb %r15b, %r15b
jne 0xa598
movq 0x8(%rbx), %rbx
movq 0x10(%r14), %r14
testq %rbx, %rbx
je 0xa590
testq %r14, %r14
jne 0xa4f9
orq %r14, %rbx
sete %al
jmp 0xa59a
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xa5be
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9d40(%rip), %rax      # 0x14708
movq %rax, (%rdi)
callq 0xa676
movq 0x10(%r14), %rax
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xa1d6
movl $0x10, %edi
callq 0x51d0
leaq 0x9d1f(%rip), %rcx      # 0x14720
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa270
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa25
callq 0x51b0
movq 0x18(%r14), %r12
testq %r12, %r12
je 0xaa9d
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %r14
leaq 0x9c93(%rip), %r13      # 0x146d0
movq 0x8(%r12), %rax
movq %r15, -0x48(%rbp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xa1d6
movl $0x20, %edi
callq 0x51d0
movq 0x18(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %r13, (%rax)
movq %r12, 0x18(%rax)
movb $0x1, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa270
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa93
callq 0x51b0
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xaa3d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0xaac3
jmp 0xaab7
movq %rax, %r14
jmp 0xaacd
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xaacd
callq 0x51b0
leaq 0x9d04(%rip), %rax      # 0x147d8
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xbaa0
movq %r14, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb40
testq %rax, %rax
je 0xab04
movq 0x28(%rax), %rax
jmp 0xab06
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/node.hpp
// Function: NExpressionArgs::generate()
void generate() {
    expr->generate();
    if (next) {
      cout << ',';
      next->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%rbx)
je 0xac38
leaq -0x9(%rbp), %rsi
movb $0x2c, (%rsi)
movq 0xa3a3(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
movq 0x8(%rbx), %rdi
callq 0xabfe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: PrintDefinition::argsMatch(NExpressionArgs*)
virtual bool argsMatch(NExpressionArgs *args) {
    for (; args != NULL; args = args->next) {
      std::string type = args->expr->get_type()->cpp_type_string();
      if (type != "std::string" && type != "int") {
        return false;
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
sete %bl
je 0xad5d
movq %rsi, %r14
leaq -0x48(%rbp), %r15
leaq 0x4785(%rip), %r12      # 0xf482
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5090
testl %eax, %eax
je 0xad37
movq %r15, %rdi
leaq 0x4c88(%rip), %rsi      # 0xf9b1
callq 0x5090
testl %eax, %eax
je 0xad37
xorl %r13d, %r13d
jmp 0xad3a
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xad4c
callq 0x51b0
testb %r13b, %r13b
je 0xad5d
movq 0x8(%r14), %r14
testq %r14, %r14
sete %bl
jne 0xacfd
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: PrintDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    cout << "std::cout";
    for (; args != NULL; args = args->next) {
      cout << " << ";
      args->expr->generate();
      // As per python, place spaces between the outputs
      if (args->next) {
        cout << " << ' '";
      }
    }
    cout << " << std::endl";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0xa241(%rip), %rdi      # 0x14fc8
leaq 0x4c36(%rip), %rsi      # 0xf9c4
movl $0x9, %edx
callq 0x5220
testq %rbx, %rbx
je 0xadeb
movq 0xa224(%rip), %r14      # 0x14fc8
leaq 0x4c23(%rip), %r15      # 0xf9ce
leaq 0x4c21(%rip), %r12      # 0xf9d3
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x8(%rbx)
je 0xade2
movl $0x7, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5220
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xadb2
movq 0xa1d6(%rip), %rdi      # 0x14fc8
leaq 0x4be2(%rip), %rsi      # 0xf9db
movl $0xd, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaef5
cmpq $0x0, 0x8(%rsi)
je 0xaf00
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4a93(%rip), %rsi      # 0xf9b1
movq %rbx, %rdi
callq 0x5090
testl %eax, %eax
je 0xaf41
leaq 0x4551(%rip), %rsi      # 0xf482
leaq -0x28(%rbp), %rdi
callq 0x5090
testl %eax, %eax
sete %bl
jmp 0xaf43
movb $0x1, %bl
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaef7
callq 0x51b0
jmp 0xaef7
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: StrCastDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    std::string type = args->expr->get_type()->cpp_type_string();
    if (type == "std::string") {
      cout << "std::string(";
    } else if (type == "int") {
      cout << "std::to_string(";
    }
    args->expr->generate();
    cout << ')';
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x44fe(%rip), %rsi      # 0xf482
movq %r14, %rdi
callq 0x5090
testl %eax, %eax
je 0xafb2
leaq 0x4a1a(%rip), %rsi      # 0xf9b1
leaq -0x38(%rbp), %rdi
callq 0x5090
testl %eax, %eax
jne 0xafca
movl $0xf, %edx
leaq 0x4a4c(%rip), %rsi      # 0xf9fc
jmp 0xafbe
movl $0xc, %edx
leaq 0x4a31(%rip), %rsi      # 0xf9ef
movq 0xa003(%rip), %rdi      # 0x14fc8
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x11(%rbp), %rsi
movb $0x29, (%rsi)
movq 0x9fe7(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaffd
callq 0x51b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb01b
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: IntCastDefinition::generateCallForArgs(NExpressionArgs*)
virtual void generateCallForArgs(NExpressionArgs *args) {
    std::string type = args->expr->get_type()->cpp_type_string();
    if (type == "std::string") {
      cout << "std::stoi(";
      args->expr->generate();
      cout << ')';
    } else if (type == "int") {
      args->expr->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4308(%rip), %rsi      # 0xf482
movq %r14, %rdi
callq 0x5090
testl %eax, %eax
je 0xb1a5
leaq 0x4824(%rip), %rsi      # 0xf9b1
leaq -0x38(%rbp), %rdi
callq 0x5090
testl %eax, %eax
jne 0xb1de
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xb1de
movq 0x9e1c(%rip), %rdi      # 0x14fc8
leaq 0x4859(%rip), %rsi      # 0xfa0c
movl $0xa, %edx
callq 0x5220
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x11(%rbp), %rsi
movb $0x29, (%rsi)
movq 0x9df4(%rip), %rdi      # 0x14fc8
movl $0x1, %edx
callq 0x5220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1f0
callq 0x51b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb20e
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb33d
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xb33d
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x46c1(%rip), %rsi      # 0xf9b1
movq %r14, %rdi
callq 0x5090
movb $0x1, %r14b
testl %eax, %eax
jne 0xb340
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xb340
cmpq $0x0, (%rax)
je 0xb340
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %rdi
movq %rax, %rsi
callq *(%rcx)
leaq 0x4688(%rip), %rsi      # 0xf9b1
leaq -0x30(%rbp), %rdi
callq 0x5090
movb $0x1, %r14b
testl %eax, %eax
je 0xb37c
xorl %ebx, %ebx
jmp 0xb388
xorl %r14d, %r14d
xorl %eax, %eax
xorl %ebx, %ebx
testb %al, %al
je 0xb35a
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb35a
callq 0x51b0
testb %r14b, %r14b
je 0xb371
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb371
callq 0x51b0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rax
cmpq $0x0, 0x8(%rax)
sete %bl
movb $0x1, %al
jmp 0xb344
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3a1
callq 0x51b0
movq %rbx, %rdi
callq 0x5340
nop