LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Mespyr[P]bop-lisp/src/env.cpp
// Function: Env::at_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
object Env::at_key(std::string key) 
{
    if (has_key(key))
    {
        return dict.at(key);
    }
    else 
    {
        return make_object(BOP_NUMBER, "0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xc0(%rbp)
movq %rsi, %rax
movq -0xc0(%rbp), %rsi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3180
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x39c0
movb %al, -0x91(%rbp)
jmp 0x387f
leaq -0x38(%rbp), %rdi
callq 0x3210
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x3894
jmp 0x38d5
movq -0xc0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x3ce0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x3d80
jmp 0x399b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x39ab
leaq -0x69(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3520
movq -0xc8(%rbp), %rdx
leaq 0x18711(%rip), %rsi     # 0x1c004
leaq -0x68(%rbp), %rdi
callq 0x3df0
jmp 0x38fe
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movq $0x0, -0x80(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3ea0
movq -0xb8(%rbp), %rdi
movq -0xd0(%rbp), %rcx
movl $0x1, %esi
leaq -0x68(%rbp), %rdx
callq 0x1b9d0
jmp 0x3941
leaq -0x90(%rbp), %rdi
callq 0x3ec0
leaq -0x68(%rbp), %rdi
callq 0x3210
leaq -0x69(%rbp), %rdi
callq 0x3370
jmp 0x399b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3990
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3ec0
leaq -0x68(%rbp), %rdi
callq 0x3210
leaq -0x69(%rbp), %rdi
callq 0x3370
jmp 0x39ab
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: Mespyr[P]bop-lisp/src/env.cpp
// Function: Env::set_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, object)
void Env::set_key(std::string key, object value) 
{
    if (has_key(key)) 
    {
        dict.find(key)->second = value;
    } 
    else 
    {
        add_key(key, value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3180
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x39c0
movb %al, -0xb1(%rbp)
jmp 0x3afb
leaq -0x38(%rbp), %rdi
callq 0x3210
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3b10
jmp 0x3b62
movq -0xd8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0x4050
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4080
movq -0xd0(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x40a0
jmp 0x3be8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x3bf1
movq -0xd8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3180
movq -0xd0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3d80
jmp 0x3b87
movq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x39f0
jmp 0x3ba0
leaq -0xb0(%rbp), %rdi
callq 0x40f0
leaq -0x70(%rbp), %rdi
callq 0x3210
jmp 0x3be8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3bdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x40f0
leaq -0x70(%rbp), %rdi
callq 0x3210
jmp 0x3bf1
addq $0xe0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: ParsingError::error[abi:cxx11]()
std::string ParsingError::error() 
{
    if (!empty_stream) 
    {
        std::string error_string;
        error_string += "Parsing Error on line " + std::to_string(tok.line) + ".\n";
        error_string += msg;
        return error_string;
    } 
    else 
    {
        std::string error_string;
        error_string += "Parsing Error on line 1.\n";
        error_string += msg;
        return error_string;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
testb $0x1, 0x48(%rax)
jne 0x80d9
movq -0xa0(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x7fde
leaq 0x1406d(%rip), %rsi     # 0x1c052
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x7ff4
leaq 0x14085(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x800a
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x801c
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3400
jmp 0x804c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x80c3
jmp 0x80b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x80c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x80ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x80a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x80c8
movq -0xa0(%rbp), %rdi
callq 0x3210
jmp 0x8153
movq -0xa0(%rbp), %rdi
callq 0x3210
jmp 0x8163
movq -0xa0(%rbp), %rdi
movb $0x0, -0x85(%rbp)
callq 0x3450
movq -0xa0(%rbp), %rdi
leaq 0x13f6f(%rip), %rsi     # 0x1c069
callq 0x32e0
jmp 0x8101
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x3400
jmp 0x8116
movb $0x1, -0x85(%rbp)
testb $0x1, -0x85(%rbp)
jne 0x8151
jmp 0x8145
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3210
jmp 0x8163
movq -0xa0(%rbp), %rdi
callq 0x3210
jmp 0x8153
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: ArgumentError::error[abi:cxx11]()
std::string ArgumentError::error() 
{
    std::string error_string;
    error_string += "Argument Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x81bd
leaq 0x13ebf(%rip), %rsi     # 0x1c083
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x81d3
leaq 0x13ea6(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x81e9
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x81fb
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3400
jmp 0x822b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x82a2
jmp 0x8296
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x82b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x828b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x82b2
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x80(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: KeywordError::error[abi:cxx11]()
std::string KeywordError::error() 
{
    std::string error_string;
    error_string += "Keyword Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x831d
leaq 0x13d77(%rip), %rsi     # 0x1c09b
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x8333
leaq 0x13d46(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x8349
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x835b
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3400
jmp 0x838b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8402
jmp 0x83f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x83eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x83e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x8412
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x80(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: DivisionByZeroError::error[abi:cxx11]()
std::string DivisionByZeroError::error() 
{
    std::string error_string;
    error_string += "DivisionByZero Error on line " + std::to_string(line) + ".\n";
    error_string += "Can't divide number by 0.";
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x847c
leaq 0x13c2f(%rip), %rsi     # 0x1c0b2
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x8492
leaq 0x13be7(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x84a8
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x84ba
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
leaq 0x13bed(%rip), %rsi     # 0x1c0d0
callq 0x32e0
jmp 0x84ea
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8561
jmp 0x8555
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8571
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x854a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x8571
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x80(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: TypeError::error[abi:cxx11]()
std::string TypeError::error() 
{
    std::string error_string;
    error_string += "Type Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x85dd
leaq 0x13b06(%rip), %rsi     # 0x1c0ea
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x85f3
leaq 0x13a86(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x8609
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x861b
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3400
jmp 0x864b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x86c2
jmp 0x86b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x86d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x86ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x86a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x86d2
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x80(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: IndexError::error[abi:cxx11]()
std::string IndexError::error() 
{
    std::string error_string;
    error_string += "Index Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x90(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x8a10
jmp 0x873d
leaq 0x139ba(%rip), %rsi     # 0x1c0fe
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x89c0
jmp 0x8753
leaq 0x13926(%rip), %rdx     # 0x1c080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8970
jmp 0x8769
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3400
jmp 0x877b
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3400
jmp 0x87ab
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8822
jmp 0x8816
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8832
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x880b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8802
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x8832
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x80(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: Mespyr[P]bop-lisp/src/errors.cpp
// Function: ErrorMap::error[abi:cxx11]()
std::string ErrorMap::error() 
{
    if (type == ARGUMENT_ERROR) 
    {
        return arg.error();
    }
    else if (type == KEYWORD_ERROR) 
    {
        return keyword.error();
    }
    else if (type == DIVISION_BY_ZERO_ERROR) 
    {
        return division.error();
    }
    else if (type == TYPE_ERROR) 
    {
        return type_.error();
    }
    else if (type == INDEX_ERROR) 
    {
        return index.error();
    }
    else 
    {
        return "Error Found with Bop: Can't get Error Type.";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, (%rax)
jne 0x888e
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x8170
jmp 0x894f
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x88ad
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x30, %rsi
callq 0x82d0
jmp 0x894f
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x88cf
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x80, %rsi
callq 0x8430
jmp 0x894f
movq -0x30(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x88eb
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x58, %rsi
callq 0x8590
jmp 0x894f
movq -0x30(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x890a
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x88, %rsi
callq 0x86f0
jmp 0x894f
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3520
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x137ed(%rip), %rsi     # 0x1c113
callq 0x3df0
jmp 0x892d
leaq -0x11(%rbp), %rdi
callq 0x3370
jmp 0x894f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3370
jmp 0x8959
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x70(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x70(%rdi)
movl 0x70(%rdi), %eax
movl %eax, -0x14(%rbp)
callq 0x13d50
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jb 0x8d29
movq -0x20(%rbp), %rax
movb $0x1, 0x74(%rax)
movq -0x20(%rbp), %rdi
movl 0x70(%rdi), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13d80
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x13dc0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_format_string[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_format_string(std::vector<object> objs) 
{
    std::string res;
    for (int i = 0; i < (int)objs.size(); i++) 
    {
        res += repr(objs.at(i));
    }
    return "'"+res+"'";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xe0(%rbp)
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3450
movl $0x0, -0x34(%rbp)
movq -0xe0(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0xe4(%rbp)
callq 0x4340
movq %rax, %rcx
movl -0xe4(%rbp), %eax
cmpl %ecx, %eax
jge 0x8f67
movq -0xe0(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x13e30
movq %rax, -0xf0(%rbp)
jmp 0x8eba
movq -0xf0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x3d80
jmp 0x8ecf
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1b840
jmp 0x8ee1
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3400
jmp 0x8ef0
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x98(%rbp), %rdi
callq 0x40f0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8e7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x8fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x8f59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3210
leaq -0x98(%rbp), %rdi
callq 0x40f0
jmp 0x8fdf
leaq 0x13f48(%rip), %rsi     # 0x1ceb6
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e70
jmp 0x8f80
movq -0xd8(%rbp), %rdi
leaq 0x13f28(%rip), %rdx     # 0x1ceb6
leaq -0xc8(%rbp), %rsi
callq 0x8970
jmp 0x8f9c
leaq -0xc8(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
movq -0xa0(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x13e30
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3180
movq -0x78(%rbp), %rdi
callq 0x1b930
movsd %xmm0, -0x70(%rbp)
jmp 0x905f
leaq -0x38(%rbp), %rdi
callq 0x3210
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x48(%rbp)
movq -0x90(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, -0x94(%rbp)
callq 0x4340
movq %rax, %rcx
movl -0x94(%rbp), %eax
cmpl %ecx, %eax
jge 0x9133
movq -0x90(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x13e30
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3180
movq -0xa8(%rbp), %rdi
callq 0x1b930
movsd %xmm0, -0xa0(%rbp)
jmp 0x90dc
movsd -0xa0(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3210
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x9151
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3210
jmp 0x9151
movq -0x88(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x13f80
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x13e30
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3180
movq -0x78(%rbp), %rdi
callq 0x1b930
movsd %xmm0, -0x70(%rbp)
jmp 0x947f
leaq -0x38(%rbp), %rdi
callq 0x3210
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x48(%rbp)
movq -0x90(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, -0x94(%rbp)
callq 0x4340
movq %rax, %rcx
movl -0x94(%rbp), %eax
cmpl %ecx, %eax
jge 0x9557
movq -0x90(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x13e30
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3180
movq -0xa8(%rbp), %rdi
callq 0x1b930
movsd %xmm0, -0xa0(%rbp)
jmp 0x94fc
movsd -0xa0(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3210
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x9575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3210
jmp 0x9575
movq -0x88(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x13f80
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nop
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3c00
movq -0xf0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3180
jmp 0x95cb
movq -0x100(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x3d80
jmp 0x95e0
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x3aa0
jmp 0x95f6
leaq -0xb8(%rbp), %rdi
callq 0x40f0
leaq -0x68(%rbp), %rdi
callq 0x3210
movq -0xf8(%rbp), %rdi
callq 0x3c60
jmp 0x9619
movq -0xf8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4160
jmp 0x9639
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x3c40
jmp 0x964e
leaq -0xe8(%rbp), %rdi
callq 0x4230
leaq -0x48(%rbp), %rdi
callq 0x4230
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x96c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x96a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x40f0
leaq -0x68(%rbp), %rdi
callq 0x3210
jmp 0x96c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x4230
leaq -0x48(%rbp), %rdi
callq 0x4230
movq -0x70(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: Mespyr[P]bop-lisp/src/main.cpp
// Function: ast_out(std::vector<Node, std::allocator<Node>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ast_out(std::vector<Node> nodes, std::string indent = "") 
{
    for (int i = 0; i < (int) nodes.size(); i++) 
    {
        Node node = nodes.at(i);
        if (node.type == ATOM) 
        {
            std::cout << indent << "TYPE: " << node.atom.type << ", LINE: " << node.atom.line << ", VALUE: " << node.atom.value << std::endl;
        } 
        else 
        {
            std::cout << indent << "NODE:\n";
            ast_out(node.nodes, indent+"    ");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0xe0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0xe0(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xe4(%rbp)
callq 0x13d50
movq %rax, %rcx
movl -0xe4(%rbp), %eax
cmpl %ecx, %eax
jge 0x16dba
movq -0xe0(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x13d80
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x13dc0
cmpl $0x1, -0x88(%rbp)
jne 0x16cc4
movq -0xd8(%rbp), %rsi
movq 0xf3e0(%rip), %rdi      # 0x25fc8
callq 0x32b0
movq %rax, -0xf0(%rbp)
jmp 0x16bf6
movq -0xf0(%rbp), %rdi
leaq 0x6205(%rip), %rsi      # 0x1ce09
callq 0x32f0
movq %rax, -0xf8(%rbp)
jmp 0x16c12
movq -0xf8(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x3500
movq %rax, -0x100(%rbp)
jmp 0x16c2a
movq -0x100(%rbp), %rdi
leaq 0x61d8(%rip), %rsi      # 0x1ce10
callq 0x32f0
movq %rax, -0x108(%rbp)
jmp 0x16c46
movq -0x108(%rbp), %rdi
movl -0x48(%rbp), %esi
callq 0x3430
movq %rax, -0x110(%rbp)
jmp 0x16c5e
movq -0x110(%rbp), %rdi
leaq 0x61ad(%rip), %rsi      # 0x1ce19
callq 0x32f0
movq %rax, -0x118(%rbp)
jmp 0x16c7a
movq -0x118(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x32b0
movq %rax, -0x120(%rbp)
jmp 0x16c93
movq -0x120(%rbp), %rdi
movq 0xf307(%rip), %rsi      # 0x25fa8
callq 0x3340
jmp 0x16ca8
jmp 0x16d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x16dac
movq -0xd8(%rbp), %rsi
movq 0xf2f6(%rip), %rdi      # 0x25fc8
callq 0x32b0
movq %rax, -0x128(%rbp)
jmp 0x16ce0
movq -0x128(%rbp), %rdi
leaq 0x6135(%rip), %rsi      # 0x1ce23
callq 0x32f0
jmp 0x16cf5
leaq -0x80(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x148c0
jmp 0x16d07
movq -0xd8(%rbp), %rsi
leaq 0x6115(%rip), %rdx      # 0x1ce2a
leaq -0xd0(%rbp), %rdi
callq 0x177b0
jmp 0x16d23
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x16b60
jmp 0x16d38
leaq -0xd0(%rbp), %rdi
callq 0x3210
leaq -0xb0(%rbp), %rdi
callq 0x149b0
jmp 0x16d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x16d84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3210
leaq -0xb0(%rbp), %rdi
callq 0x149b0
jmp 0x16dac
leaq -0x88(%rbp), %rdi
callq 0x141d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16b88
leaq -0x88(%rbp), %rdi
callq 0x141d0
jmp 0x16dc3
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3510
nop
// File: 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
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1771a
callq 0x17140
movl $0x0, -0x4(%rbp)
jmp 0x17794
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1bc80
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3180
jmp 0x1773e
leaq -0x50(%rbp), %rdi
callq 0x16dd0
movl %eax, -0x6c(%rbp)
jmp 0x1774c
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
jmp 0x17794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x17789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
jmp 0x1779d
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
callq 0x3480
cmpq $0x2, %rax
jb 0x19248
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x3550
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x19248
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x3320
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33d0
leaq -0x30(%rbp), %rdi
callq 0x3210
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3480
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x192be
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3550
movb (%rax), %al
movb %al, -0x35(%rbp)
movsbl -0x35(%rbp), %edi
callq 0x191a0
andb $0x1, %al
movb %al, -0x9(%rbp)
movsbl -0x35(%rbp), %eax
cmpl $0x2e, %eax
jne 0x192a9
movb -0xa(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x192b1
jmp 0x192be
jmp 0x192b3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1924f
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3250
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x19307
movq -0x48(%rbp), %rdi
callq 0x30f0
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x19307
movl $0x1, -0x4(%rbp)
jmp 0x19361
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3180
movq -0x58(%rbp), %rdi
callq 0x191e0
movb %al, -0x49(%rbp)
jmp 0x19326
leaq -0x30(%rbp), %rdi
callq 0x3210
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x19338
jmp 0x19358
movl $0x0, -0x4(%rbp)
jmp 0x19361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3210
jmp 0x1936a
jmp 0x1935a
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3450
movq -0x58(%rbp), %rdi
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movl $0x0, 0x28(%rdi)
addq $0x30, %rdi
callq 0x3450
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x193dd
leaq -0x38(%rbp), %rdi
callq 0x192d0
movl %eax, -0x64(%rbp)
jmp 0x193eb
movq -0x58(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, 0x24(%rax)
leaq -0x38(%rbp), %rdi
callq 0x3210
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x8, %rsi
callq 0x3040
jmp 0x19411
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl (%rsi), %eax
movl %eax, 0x20(%rdi)
addq $0x28, %rdi
callq 0x1a030
jmp 0x19429
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x19463
jmp 0x1945a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1946d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3210
jmp 0x1946d
movq -0x58(%rbp), %rdi
callq 0x140a0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x140a0
movq -0x40(%rbp), %rdi
callq 0x3510
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x18(%rdi)
movl 0x18(%rdi), %eax
movl %eax, -0x14(%rbp)
callq 0x17aa0
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jl 0x1a0b9
movq -0x20(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x20(%rbp), %rdi
movl 0x18(%rdi), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x1a420
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x15530
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, (%rsi)
jne 0x1b87a
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x8, %rsi
callq 0x3180
jmp 0x1b90e
movq -0x60(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1b8c8
leaq -0x11(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3520
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x1619(%rip), %rsi      # 0x1ceb8
callq 0x3df0
jmp 0x1b8a6
leaq -0x11(%rbp), %rdi
callq 0x3370
jmp 0x1b90e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3370
jmp 0x1b918
movq -0x60(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3180
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1b7f0
jmp 0x1b8ec
leaq -0x48(%rbp), %rdi
callq 0x3210
jmp 0x1b90e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3210
jmp 0x1b918
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x1bac0
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
cmpl $0x2, -0xc(%rbp)
jne 0x1ba3e
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x4b10
jmp 0x1ba25
jmp 0x1ba53
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x40f0
jmp 0x1ba70
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x3040
jmp 0x1ba51
jmp 0x1ba53
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1ba66
movq -0x40(%rbp), %rdi
callq 0x40f0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: Mespyr[P]bop-lisp/src/util.cpp
// Function: read_ascii_file[abi:cxx11](char const*)
std::string read_ascii_file(const char* path) 
{
    // file
	std::fstream file;
	file.open(path, std::ios::in);
    std::string code;

	if (!file) 
	{
		std::cout << "Error: No such file or directory '" << path << "'" << std::endl;
        exit(1);
	}
	else 
	{
		std::string ch;
		
		while (getline(file, ch))
		{  
			code += ch + '\n';  
		}
	}
	file.close();
	return code+"\0";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x2a8(%rbp)
movq %rdi, %rax
movq %rax, -0x2a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x33b0
movq -0x298(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x32c0
jmp 0x1bcce
leaq -0x250(%rbp), %rdi
callq 0x3450
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x31b0
movb %al, -0x2a9(%rbp)
jmp 0x1bcfa
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x1bd09
jmp 0x1bda7
movq 0xa2b8(%rip), %rdi      # 0x25fc8
leaq 0x11ad(%rip), %rsi      # 0x1cec4
callq 0x32f0
movq %rax, -0x2b8(%rbp)
jmp 0x1bd25
movq -0x2b8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x32f0
movq %rax, -0x2c0(%rbp)
jmp 0x1bd3e
movq -0x2c0(%rbp), %rdi
leaq 0x116a(%rip), %rsi      # 0x1ceb6
callq 0x32f0
movq %rax, -0x2c8(%rbp)
jmp 0x1bd5a
movq -0x2c8(%rbp), %rdi
movq 0xa240(%rip), %rsi      # 0x25fa8
callq 0x3340
jmp 0x1bd6f
movl $0x1, %edi
callq 0x33c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1bee7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1bedb
leaq -0x270(%rbp), %rdi
callq 0x3450
leaq -0x220(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x30c0
movq %rax, -0x2d0(%rbp)
jmp 0x1bdcf
movq -0x2d0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33f0
movb %al, -0x2d1(%rbp)
jmp 0x1bded
movb -0x2d1(%rbp), %al
testb $0x1, %al
jne 0x1bdf9
jmp 0x1be6d
leaq -0x290(%rbp), %rdi
leaq -0x270(%rbp), %rsi
movl $0xa, %edx
callq 0x1bf00
jmp 0x1be13
leaq -0x250(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x3400
jmp 0x1be28
leaq -0x290(%rbp), %rdi
callq 0x3210
jmp 0x1bdb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1be7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x3210
jmp 0x1be7b
leaq -0x270(%rbp), %rdi
callq 0x3210
jmp 0x1be89
leaq -0x270(%rbp), %rdi
callq 0x3210
jmp 0x1bedb
leaq -0x220(%rbp), %rdi
callq 0x3070
jmp 0x1be97
movq -0x2a8(%rbp), %rdi
leaq 0x1042(%rip), %rdx      # 0x1cee7
leaq -0x250(%rbp), %rsi
callq 0x177b0
jmp 0x1beb3
leaq -0x250(%rbp), %rdi
callq 0x3210
leaq -0x220(%rbp), %rdi
callq 0x30d0
movq -0x2a0(%rbp), %rax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
leaq -0x250(%rbp), %rdi
callq 0x3210
leaq -0x220(%rbp), %rdi
callq 0x30d0
movq -0x228(%rbp), %rdi
callq 0x3510
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
callq 0xbe80
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq *%rax
movq -0x48(%rbp), %rsi
movq 0x135c2(%rip), %rdi     # 0x1efc0
callq 0x51f0
movq %rax, -0x40(%rbp)
jmp 0xba09
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x5280
movq %rax, -0x58(%rbp)
jmp 0xba1d
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x10, %rsi
callq 0x51f0
movq %rax, -0x60(%rbp)
jmp 0xba38
movq -0x60(%rbp), %rdi
movl $0x28, %esi
callq 0x5280
jmp 0xba48
leaq -0x28(%rbp), %rdi
callq 0x5190
movq -0x50(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xba83
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xba83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5190
jmp 0xba9c
movq 0x13536(%rip), %rdi     # 0x1efc0
leaq 0xae58(%rip), %rsi      # 0x168e9
callq 0x5210
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5400
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x1241b(%rip), %rdi     # 0x1efc0
leaq 0x9943(%rip), %rsi      # 0x164ef
callq 0x5210
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x123fa(%rip), %rdi     # 0x1efc0
leaq 0x9924(%rip), %rsi      # 0x164f1
callq 0x5210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0xcd71
jmp 0xcd9d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xcdb7
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq 0x1203a(%rip), %rdi     # 0x1efc0
leaq 0x9566(%rip), %rsi      # 0x164f3
callq 0x5210
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x12019(%rip), %rdi     # 0x1efc0
leaq 0x9853(%rip), %rsi      # 0x16801
callq 0x5210
movq %rax, %rdi
movq 0x11fe3(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbeb0
movq 0x11fd8(%rip), %rdi     # 0x1efc0
leaq 0x950c(%rip), %rsi      # 0x164fb
callq 0x5210
movq %rax, %rdi
movq 0x11fa2(%rip), %rsi     # 0x1efa0
callq 0x5240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0xbe80
movq 0x11f8a(%rip), %rdi     # 0x1efc0
leaq 0x94c5(%rip), %rsi      # 0x16502
callq 0x5210
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x11f69(%rip), %rdi     # 0x1efc0
leaq 0x97a3(%rip), %rsi      # 0x16801
callq 0x5210
movq %rax, %rdi
movq 0x11f33(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbeb0
movq 0x11f28(%rip), %rdi     # 0x1efc0
leaq 0x945c(%rip), %rsi      # 0x164fb
callq 0x5210
movq %rax, %rdi
movq 0x11ef2(%rip), %rsi     # 0x1efa0
callq 0x5240
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd0d0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0xd0ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xd0eb
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0xd0ed
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)