LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_islambda(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_islambda(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->islambda() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xc0fd
movq 0x21f20(%rip), %rdi     # 0x2dff0
leaq 0x15159(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x21eaa(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xc212
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7590
movb %al, -0x71(%rbp)
jmp 0xc134
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xc13d
jmp 0xc17f
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x1569a(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xc16a
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xc17d
jmp 0xc18c
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xc18a
jmp 0xc18c
testb $0x1, -0x5b(%rbp)
jne 0xc194
jmp 0xc19d
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xc1a5
jmp 0xc1ae
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xc212
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc1f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xc1e9
jmp 0xc1f2
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xc1f4
testb $0x1, -0x5a(%rbp)
jne 0xc1fc
jmp 0xc205
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xc207
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xc21f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_quote(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_quote(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1 ) {
        cerr << "quote expects only one argument" << endl;
        return nullptr;
    }
    return args->car();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xcba7
movq 0x21473(%rip), %rdi     # 0x2dff0
leaq 0x1478e(%rip), %rsi     # 0x21312
callq 0x32c0
movq %rax, %rdi
movq 0x213fd(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xcbbc
movq -0x10(%rbp), %rdi
callq 0x4400
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xb520
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_unquote(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_unquote(const sexpr_t& args, env_t& bindings) {
    if (args->length() != 1 ) {
        cerr << "unquote expects only one argument" << endl;
        return nullptr;
    }
    cout << "aegrs: " << args << endl;
    return ::eval(args->car(), bindings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xcc3d
movq 0x213e0(%rip), %rdi     # 0x2dff0
leaq 0x146cc(%rip), %rsi     # 0x212e3
callq 0x32c0
movq %rax, %rdi
movq 0x2136a(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xccf8
movq 0x21384(%rip), %rdi     # 0x2dfc8
leaq 0x146ba(%rip), %rsi     # 0x21305
callq 0x32c0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x43d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x10b90
movq %rax, -0x60(%rbp)
jmp 0xcc78
movq -0x60(%rbp), %rdi
movq 0x2130d(%rip), %rsi     # 0x2df90
callq 0x32f0
jmp 0xcc8a
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xb520
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x19aa0
jmp 0xccbf
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0xccf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xcd05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0xcd05
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nop
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_print(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_print(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    sexpr_t walk = args;

    while (not walk->isnil()) {
        cout << walk->car() << (walk->cdr()->isnil() ? "\n" : " ");
        walk = walk->cdr();
    }
    return nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x79(%rbp)
jmp 0xd525
movb -0x79(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd533
jmp 0xd654
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb520
jmp 0xd54a
movq 0x20a77(%rip), %rdi     # 0x2dfc8
leaq -0x48(%rbp), %rsi
callq 0x10b90
movq %rax, -0x88(%rbp)
jmp 0xd563
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xb440
jmp 0xd57a
leaq -0x58(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x89(%rbp)
jmp 0xd593
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xd59f
jmp 0xd5af
leaq 0x14193(%rip), %rax     # 0x21739
movq %rax, -0x98(%rbp)
jmp 0xd5bf
leaq 0x13fae(%rip), %rax     # 0x21564
movq %rax, -0x98(%rbp)
jmp 0xd5bf
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x32c0
jmp 0xd5d4
leaq -0x58(%rbp), %rdi
callq 0x4450
leaq -0x48(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0xb440
jmp 0xd5fd
leaq -0x28(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4420
leaq -0x68(%rbp), %rdi
callq 0x4450
jmp 0xd50f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd675
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd649
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4450
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0xd675
movq -0x78(%rbp), %rdi
callq 0x78f0
jmp 0xd65f
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_and(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_and(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    sexpr_t walk = args;

    while (not walk->isnil()) {
        if (walk->car()->isnil())
            return nil();
        walk = walk->cdr();
    }
    return symb("t");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x99(%rbp)
jmp 0xd6de
movb -0x99(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd6ef
jmp 0xd7ab
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb520
jmp 0xd706
leaq -0x48(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x9a(%rbp)
jmp 0xd71f
leaq -0x48(%rbp), %rdi
callq 0x4450
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0xd734
jmp 0xd779
movq -0x98(%rbp), %rdi
callq 0x78f0
jmp 0xd742
movl $0x1, -0x4c(%rbp)
jmp 0xd838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd851
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0xd851
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xb440
jmp 0xd790
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4420
leaq -0x60(%rbp), %rdi
callq 0x4450
jmp 0xd6c5
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3500
movq -0xa8(%rbp), %rdx
leaq 0x1402d(%rip), %rsi     # 0x217f9
leaq -0x80(%rbp), %rdi
callq 0xc230
jmp 0xd7d7
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7920
jmp 0xd7e9
leaq -0x80(%rbp), %rdi
callq 0x31d0
leaq -0x81(%rbp), %rdi
callq 0x3310
movl $0x1, -0x4c(%rbp)
jmp 0xd838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd82a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31d0
leaq -0x81(%rbp), %rdi
callq 0x3310
jmp 0xd851
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_or(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_or(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    sexpr_t walk = args;

    while (not walk->isnil()) {
        if (not walk->car()->isnil())
            return symb("t");
        walk = walk->cdr();
    }
    return nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x91(%rbp)
jmp 0xd8be
movb -0x91(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd8cf
jmp 0xda09
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb520
jmp 0xd8e6
leaq -0x48(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x92(%rbp)
jmp 0xd8ff
movb -0x92(%rbp), %al
xorb $-0x1, %al
movb %al, -0x93(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
movb -0x93(%rbp), %al
testb $0x1, %al
jne 0xd925
jmp 0xd9d7
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3500
movq -0xa0(%rbp), %rdx
leaq 0x13eb6(%rip), %rsi     # 0x217f9
leaq -0x68(%rbp), %rdi
callq 0xc230
jmp 0xd94e
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7920
jmp 0xd960
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x69(%rbp), %rdi
callq 0x3310
movl $0x1, -0x70(%rbp)
jmp 0xda1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xda37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0xda37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd9cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x69(%rbp), %rdi
callq 0x3310
jmp 0xda37
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xb440
jmp 0xd9ee
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4420
leaq -0x80(%rbp), %rdi
callq 0x4450
jmp 0xd8a5
movq -0x90(%rbp), %rdi
callq 0x78f0
jmp 0xda17
movl $0x1, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_not(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_not(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: not takes only one argument" << endl;
        return nullptr;
    }
    return args->car()->isnil() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xdabd
movq 0x20560(%rip), %rdi     # 0x2dff0
leaq 0x138b4(%rip), %rsi     # 0x2134b
callq 0x32c0
movq %rax, %rdi
movq 0x204ea(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xdbd2
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7270
movb %al, -0x71(%rbp)
jmp 0xdaf4
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xdafd
jmp 0xdb3f
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x13cda(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xdb2a
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xdb3d
jmp 0xdb4c
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xdb4a
jmp 0xdb4c
testb $0x1, -0x5b(%rbp)
jne 0xdb54
jmp 0xdb5d
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xdb65
jmp 0xdb6e
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xdbd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xdbc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xdbb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xdba9
jmp 0xdbb2
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xdbb4
testb $0x1, -0x5a(%rbp)
jne 0xdbbc
jmp 0xdbc5
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xdbc7
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xdbdf
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_eval(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_eval(const sexpr_t& args, env_t& bindings) {
    if (args->length() != 1) {
        cerr << "Err: eval expects one expression" << endl;
        return nullptr;
    }
    return ::eval(args->car(), bindings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xe327
movq 0x1fcf3(%rip), %rdi     # 0x2dff0
leaq 0x13131(%rip), %rsi     # 0x21435
callq 0x32c0
movq %rax, %rdi
movq 0x1fc7d(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xe375
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb520
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x19aa0
jmp 0xe353
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xe375
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xe37f
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_begin(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_begin(const sexpr_t& args, env_t& bindings) {
    sexpr_t walk = args;
    sexpr_t res = nil();

    while (not walk->isnil()) {
        res = ::eval(walk->car(), bindings);
        if (not res) return nullptr;
        walk = walk->cdr();
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
leaq -0x38(%rbp), %rdi
callq 0x78f0
jmp 0xe7c0
jmp 0xe7c2
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x91(%rbp)
jmp 0xe7db
movb -0x91(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe7ec
jmp 0xe8c9
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0xb520
jmp 0xe803
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x19aa0
jmp 0xe816
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4420
leaq -0x58(%rbp), %rdi
callq 0x4450
leaq -0x68(%rbp), %rdi
callq 0x4450
leaq -0x38(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0xe897
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
movl $0x1, -0x6c(%rbp)
jmp 0xe8e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xe90b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xe902
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4450
jmp 0xe902
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xb440
jmp 0xe8ae
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4420
leaq -0x80(%rbp), %rdi
callq 0x4450
jmp 0xe7c2
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa6f0
movl $0x1, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x40(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 0x0584[P]scmin-plus/include/sexpr.hpp
// Function: operator<<(std::ostream&, sexpr::sexpr_conslist*)
ostream& operator<<(ostream& os, sexpr_conslist *c) {
            os << "(" << c->car;
            for (auto e = c->cdr; not e->isnil(); e = e->cdr()) {
                if (not e->isatom())
                    os << " " << e->car();
                else {
                     os << " . " << e;
                     break;
                }
            }
            os << ")";
            return os;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x10562(%rip), %rsi     # 0x21560
callq 0x32c0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x43d0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x10b90
jmp 0x1102d
leaq -0x20(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
callq 0x43d0
leaq -0x40(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x89(%rbp)
jmp 0x11060
movb -0x89(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x110a3
movl $0x2, -0x44(%rbp)
jmp 0x111d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4450
jmp 0x11204
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x111dc
leaq -0x40(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x73d0
movb %al, -0x8a(%rbp)
jmp 0x110bc
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x11132
jmp 0x110c8
movq -0x8(%rbp), %rdi
leaq 0x10491(%rip), %rsi     # 0x21564
callq 0x32c0
movq %rax, -0x98(%rbp)
jmp 0x110e1
leaq -0x40(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xb520
jmp 0x110f8
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10b90
jmp 0x1110a
leaq -0x58(%rbp), %rdi
callq 0x4450
jmp 0x1119d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4450
jmp 0x111dc
movq -0x8(%rbp), %rdi
leaq 0x10425(%rip), %rsi     # 0x21562
callq 0x32c0
movq %rax, -0xa0(%rbp)
jmp 0x1114b
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x43d0
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x10b90
jmp 0x11174
leaq -0x68(%rbp), %rdi
callq 0x4450
movl $0x2, -0x44(%rbp)
jmp 0x111d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4450
jmp 0x111dc
jmp 0x1119f
leaq -0x40(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0xb440
jmp 0x111b6
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4420
leaq -0x78(%rbp), %rdi
callq 0x4450
jmp 0x11047
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x111e7
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x11204
movq -0x8(%rbp), %rdi
leaq 0x107df(%rip), %rsi     # 0x219d1
callq 0x32c0
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 0x0584[P]scmin-plus/include/sexpr.hpp
// Function: operator<<(std::ostream&, sexpr::sexpr_lambda)
ostream& operator<<(ostream& os, sexpr_lambda b) {
            if (b.native)
                os << "[built-in]";
            else
                os << "[args: " << b.args << ", body: " << b.body << "]";
            return os;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x58(%rsi)
je 0x11243
movq -0x8(%rbp), %rdi
leaq 0x1032d(%rip), %rsi     # 0x21566
callq 0x32c0
jmp 0x1130d
movq -0x8(%rbp), %rdi
leaq 0x10323(%rip), %rsi     # 0x21571
callq 0x32c0
movq -0x48(%rbp), %rsi
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x43d0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x10b90
movq %rax, -0x50(%rbp)
jmp 0x1127b
movq -0x50(%rbp), %rdi
leaq 0x102f3(%rip), %rsi     # 0x21579
callq 0x32c0
movq %rax, -0x68(%rbp)
jmp 0x11291
movq -0x48(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x43d0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x10b90
movq %rax, -0x70(%rbp)
jmp 0x112b9
movq -0x70(%rbp), %rdi
leaq 0x102ab(%rip), %rsi     # 0x2156f
callq 0x32c0
jmp 0x112cb
leaq -0x40(%rbp), %rdi
callq 0x4450
leaq -0x20(%rbp), %rdi
callq 0x4450
jmp 0x1130d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x11302
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4450
leaq -0x20(%rbp), %rdi
callq 0x4450
jmp 0x1131a
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 0x0584[P]scmin-plus/src/builtin/cons.cpp
// Function: builtin::_cons(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_cons(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 2) {
        cerr << "cons operator requires exactly two arguments" << endl;
        return nullptr;
    }
    return cons(args->car(), args->cdr()->car());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x2, %rax
je 0x1318a
movq 0x1ae93(%rip), %rdi     # 0x2dff0
leaq 0xe41e(%rip), %rsi      # 0x21582
callq 0x32c0
movq %rax, %rdi
movq 0x1ae1d(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0x13242
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0xb520
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb440
jmp 0x131b6
leaq -0x48(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xb520
jmp 0x131cd
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x7a40
jmp 0x131e0
leaq -0x38(%rbp), %rdi
callq 0x4450
leaq -0x48(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x13242
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x13237
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1322e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4450
leaq -0x48(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x1324c
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/arithmetic.cpp
// Function: valid_numeric_args(std::shared_ptr<sexpr>)
bool valid_numeric_args(sexpr_t args) {
    if (args->length() != 2) {
        cerr << "Err: expected two arguments!" << endl;
        return false;
    }
    if (not (args->car()->isnum() and args->cdr()->car()->isnum())) {
        cerr << "Err: arguments should both be numbers!" << endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x2, %rax
je 0x14731
movq 0x198e3(%rip), %rdi     # 0x2dff0
leaq 0xcf85(%rip), %rsi      # 0x21699
callq 0x32c0
movq %rax, %rdi
movq 0x1986d(%rip), %rsi     # 0x2df90
callq 0x32f0
movb $0x0, -0x1(%rbp)
jmp 0x1488f
movq -0x60(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xb520
movq -0x70(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x51(%rbp)
movb $0x0, -0x52(%rbp)
callq 0x7430
movb %al, -0x61(%rbp)
jmp 0x14768
movb -0x61(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x14777
jmp 0x147cb
movq -0x60(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xb440
jmp 0x1478e
movb $0x1, -0x51(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xb520
jmp 0x147a9
movb $0x1, -0x52(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7430
movb %al, -0x72(%rbp)
jmp 0x147c3
movb -0x72(%rbp), %al
movb %al, -0x71(%rbp)
jmp 0x147cb
movb -0x71(%rbp), %al
xorb $-0x1, %al
movb %al, -0x73(%rbp)
testb $0x1, -0x52(%rbp)
jne 0x147db
jmp 0x147e4
leaq -0x40(%rbp), %rdi
callq 0x4450
testb $0x1, -0x51(%rbp)
jne 0x147ec
jmp 0x147f5
leaq -0x50(%rbp), %rdi
callq 0x4450
leaq -0x20(%rbp), %rdi
callq 0x4450
movb -0x73(%rbp), %al
testb $0x1, %al
jne 0x1480a
jmp 0x1488b
movq 0x197df(%rip), %rdi     # 0x2dff0
leaq 0xce9e(%rip), %rsi      # 0x216b6
callq 0x32c0
movq %rax, %rdi
movq 0x19769(%rip), %rsi     # 0x2df90
callq 0x32f0
movb $0x0, -0x1(%rbp)
jmp 0x1488f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x14880
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1486d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x52(%rbp)
jne 0x14862
jmp 0x1486b
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x1486d
testb $0x1, -0x51(%rbp)
jne 0x14875
jmp 0x1487e
leaq -0x50(%rbp), %rdi
callq 0x4450
jmp 0x14880
leaq -0x20(%rbp), %rdi
callq 0x4450
jmp 0x1489d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/eval.cpp
// Function: sexpr::resolve(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t sexpr::resolve(const sexpr_t& expr, env_t& local) {
    if (not (expr and expr->issymb()))
        return expr;
    auto sy = any_cast<sexpr_text>(*expr->blob).text();
    auto it = local.find(sy);
    if (it != end(local))
        return it->second;
    it = global.find(sy);
    if (it != end(global))
        return it->second;
    else return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0x16c07
jmp 0x16c1c
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7500
testb $0x1, %al
jne 0x16c31
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43d0
jmp 0x16dd6
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x4520
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x44d0
movq -0xb0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3a60
jmp 0x16c67
leaq -0x60(%rbp), %rdi
callq 0x4550
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10b00
movq %rax, -0xb8(%rbp)
jmp 0x16c86
movq -0xb8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10b30
movq %rax, -0xc0(%rbp)
jmp 0x16ca3
movq -0xc0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10ad0
testb $0x1, %al
jne 0x16cc1
jmp 0x16d20
leaq -0x78(%rbp), %rdi
callq 0x66f0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x43d0
movl $0x1, -0x84(%rbp)
jmp 0x16dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4550
jmp 0x16de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
jmp 0x16de6
leaq 0x175c1(%rip), %rdi     # 0x2e2e8
leaq -0x38(%rbp), %rsi
callq 0x10b00
movq %rax, -0xc8(%rbp)
jmp 0x16d39
movq -0xc8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x1758f(%rip), %rdi     # 0x2e2e8
callq 0x10b30
movq %rax, -0xd0(%rbp)
jmp 0x16d67
movq -0xd0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x10ad0
testb $0x1, %al
jne 0x16d8b
jmp 0x16db3
leaq -0x78(%rbp), %rdi
callq 0x66f0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x43d0
movl $0x1, -0x84(%rbp)
jmp 0x16dcd
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43d0
movl $0x1, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x34f0
nop
// File: 0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse_pair(std::queue<token, std::deque<token, std::allocator<token>>>&, std::shared_ptr<sexpr> const&, std::shared_ptr<sexpr>&)
sexpr_t parse_pair(queue<token>& q, const sexpr_t& e, sexpr_t& tail) {
    if (q.pop(); not e or tok.type == token::tok_r_paren) {
        cerr << "parsing error! pair is not valid" << endl;
        return nullptr;
    }
    sexpr_t tmp = tok;
    if (q.pop(); not tmp->isatom() or tok.type != token::tok_r_paren) {
        cerr << "parsing error! pair is not valid" << endl;
        return nullptr;
    }
    tail->setcdr(tmp);
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b7c0
movq -0x18(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0x1a50b
jmp 0x1a51a
movq -0x10(%rbp), %rdi
callq 0x1b7a0
cmpl $0x1, 0x7c(%rax)
jne 0x1a54e
movq 0x13acf(%rip), %rdi     # 0x2dff0
leaq 0x7336(%rip), %rsi      # 0x2185e
callq 0x32c0
movq %rax, %rdi
movq 0x13a59(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0x1a632
movq -0x10(%rbp), %rdi
callq 0x1b7a0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1b800
movq -0x10(%rbp), %rdi
callq 0x1b7c0
jmp 0x1a56e
leaq -0x30(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x73d0
movb %al, -0x51(%rbp)
jmp 0x1a584
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1a58d
jmp 0x1a5a6
movq -0x10(%rbp), %rdi
callq 0x1b7a0
movq %rax, -0x60(%rbp)
jmp 0x1a59c
movq -0x60(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
je 0x1a5fe
movq 0x13a43(%rip), %rdi     # 0x2dff0
leaq 0x72aa(%rip), %rsi      # 0x2185e
callq 0x32c0
movq %rax, -0x68(%rbp)
jmp 0x1a5bf
movq -0x68(%rbp), %rdi
movq 0x139c6(%rip), %rsi     # 0x2df90
callq 0x32f0
jmp 0x1a5d1
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
movl $0x1, -0x40(%rbp)
jmp 0x1a629
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4450
jmp 0x1a63c
movq -0x20(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0xb3d0
jmp 0x1a615
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43d0
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4450
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse_lambda(std::queue<token, std::deque<token, std::allocator<token>>>&, std::shared_ptr<sexpr>&)
sexpr_t parse_lambda(queue<token>& q, sexpr_t& e) {
    if (q.pop(); e or tok.type != token::tok_l_paren) {
        cerr << "lambda args is mal-formatted" << endl;
        return nullptr;
    }
    auto args = parse_tokens(q);
    if (tok.type != token::tok_l_paren) {
        cerr << "lambda body is mal-formatted" << endl;
        return nullptr;
    }
    auto body = parse_tokens(q);
    if (tok.type != token::tok_r_paren) {
        cerr << "lambda is mal-formatted" << endl;
        return nullptr;
    }
    return (e = lambda(args, body));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b7c0
movq -0x18(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0x1a697
movq -0x10(%rbp), %rdi
callq 0x1b7a0
cmpl $0x0, 0x7c(%rax)
je 0x1a6cb
movq 0x13952(%rip), %rdi     # 0x2dff0
leaq 0x71da(%rip), %rsi      # 0x2187f
callq 0x32c0
movq %rax, %rdi
movq 0x138dc(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0x1a82b
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x1a190
movq -0x10(%rbp), %rdi
callq 0x1b7a0
movq %rax, -0x70(%rbp)
jmp 0x1a6e9
movq -0x70(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
je 0x1a748
movq 0x138f6(%rip), %rdi     # 0x2dff0
leaq 0x719b(%rip), %rsi      # 0x2189c
callq 0x32c0
movq %rax, -0x78(%rbp)
jmp 0x1a70c
movq -0x78(%rbp), %rdi
movq 0x13879(%rip), %rsi     # 0x2df90
callq 0x32f0
jmp 0x1a71e
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
movl $0x1, -0x38(%rbp)
jmp 0x1a815
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1a820
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1a190
jmp 0x1a759
movq -0x10(%rbp), %rdi
callq 0x1b7a0
movq %rax, -0x80(%rbp)
jmp 0x1a768
movq -0x80(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
je 0x1a7d0
movq 0x13877(%rip), %rdi     # 0x2dff0
leaq 0x7139(%rip), %rsi      # 0x218b9
callq 0x32c0
movq %rax, -0x88(%rbp)
jmp 0x1a78e
movq -0x88(%rbp), %rdi
movq 0x137f4(%rip), %rsi     # 0x2df90
callq 0x32f0
jmp 0x1a7a3
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
movl $0x1, -0x38(%rbp)
jmp 0x1a80c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x1a820
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x79c0
jmp 0x1a7e3
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4420
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x43d0
leaq -0x58(%rbp), %rdi
callq 0x4450
movl $0x1, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x1a82b
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x1a838
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
sexpr_t parse(string s) {
    queue<token> tokens;
    sexpr_t e;

    if ((tokens = token::tokenize(s)).size() == 0)
        return nullptr;
    e = parse_tokens(tokens);
    // cout << "expr: " << e << endl;
    if (not e)
        cerr << "Err: expression is mal-formed" << endl;
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0xe8(%rbp)
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1baf0
leaq -0x70(%rbp), %rdi
callq 0x6ef0
movq -0xe8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x1e5d0
jmp 0x1b642
leaq -0x60(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1bb20
movq %rax, %rdi
callq 0x1b7e0
movq %rax, -0x100(%rbp)
jmp 0x1b663
leaq -0xc0(%rbp), %rdi
callq 0x1bb50
movq -0x100(%rbp), %rax
cmpq $0x0, %rax
jne 0x1b6d5
movq -0xf8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
movl $0x1, -0xd0(%rbp)
jmp 0x1b75f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x1b781
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1bb50
jmp 0x1b781
leaq -0xe0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x1a190
jmp 0x1b6e9
leaq -0x70(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x4420
leaq -0xe0(%rbp), %rdi
callq 0x4450
leaq -0x70(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0x1b745
movq 0x128d7(%rip), %rdi     # 0x2dff0
leaq 0x6238(%rip), %rsi      # 0x21958
callq 0x32c0
movq %rax, -0x108(%rbp)
jmp 0x1b72e
movq -0x108(%rbp), %rdi
movq 0x12854(%rip), %rsi     # 0x2df90
callq 0x32f0
jmp 0x1b743
jmp 0x1b745
movq -0xf8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa6f0
movl $0x1, -0xd0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4450
leaq -0x60(%rbp), %rdi
callq 0x1bb50
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x4450
leaq -0x60(%rbp), %rdi
callq 0x1bb50
movq -0xc8(%rbp), %rdi
callq 0x34f0
nop
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_paren(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_paren(string& e) {
    char c = e[0];

    if (c != '(' and c != ')')
        return false;
    e.erase(0, 1);
    s = c;
    type = c == '(' ? tok_l_paren : tok_r_paren;
    if (c == ')') {
        if (paren.size() == 0 or paren.top() != '(')
            return err = true;
        paren.pop();
        return true;
    } else if (c == '(') {
        paren.push(c);
        return true;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
je 0x1ddf5
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
je 0x1ddf5
movb $0x0, -0x1(%rbp)
jmp 0x1dea6
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x30a0
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x34a0
movq -0x28(%rbp), %rax
movsbl -0x19(%rbp), %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x28, %esi
cmovel %edx, %ecx
movl %ecx, 0x7c(%rax)
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
jne 0x1de81
leaq 0x104ee(%rip), %rdi     # 0x2e330
callq 0x1ba60
cmpq $0x0, %rax
je 0x1de61
leaq 0x104dc(%rip), %rdi     # 0x2e330
callq 0x1ba80
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0x1de6f
movq -0x28(%rbp), %rax
movb $0x1, 0x78(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1dea6
leaq 0x104ba(%rip), %rdi     # 0x2e330
callq 0x1baa0
movb $0x1, -0x1(%rbp)
jmp 0x1dea6
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0x1dea0
leaq 0x1049f(%rip), %rdi     # 0x2e330
leaq -0x19(%rbp), %rsi
callq 0x1e870
movb $0x1, -0x1(%rbp)
jmp 0x1dea6
jmp 0x1dea2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_string(string& e) {
    int j = 1;
    if (e[0] != '\"')
        return false;
    type = tok_str;
    for (; e[j] != '\"'; j++)
        if (e[j]) s += e[j];
        else return err = true;
    e.erase(0, j + 1);
    return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x1defd
movb $0x0, -0x1(%rbp)
jmp 0x1df85
movq -0x28(%rbp), %rax
movl $0x2, 0x7c(%rax)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3570
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x1df6b
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3570
cmpb $0x0, (%rax)
je 0x1df50
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3570
movq -0x28(%rbp), %rdi
movb (%rax), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x31e0
jmp 0x1df5e
movq -0x28(%rbp), %rax
movb $0x1, 0x78(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1df85
jmp 0x1df60
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1df08
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq