LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_ispair(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::_ispair(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->ispair() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x646a
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4d5c
movl %eax, %r14d
testb %al, %al
je 0x64b4
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd3dd(%rip), %rsi      # 0x13829
leaq 0xd3d7(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x64bc
movq 0x13b77(%rip), %r14     # 0x19fe8
leaq 0xce00(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x64e8
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x64da
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64da
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x64e8
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x651d
movq %rax, %rbx
testb %r14b, %r14b
je 0x651d
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x651d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x6525
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6533
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_islist(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::_islist(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->islist() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x65a6
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4cf4
movl %eax, %r14d
testb %al, %al
je 0x65f0
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd2a1(%rip), %rsi      # 0x13829
leaq 0xd29b(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x65f8
movq 0x13a3b(%rip), %r14     # 0x19fe8
leaq 0xccc4(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6624
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x6616
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6616
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6624
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x6659
movq %rax, %rbx
testb %r14b, %r14b
je 0x6659
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6659
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x6661
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x666f
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isnum(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::_isnum(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isnum() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x66e2
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4dfa
movl %eax, %r14d
testb %al, %al
je 0x672c
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd165(%rip), %rsi      # 0x13829
leaq 0xd15f(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x6734
movq 0x138ff(%rip), %r14     # 0x19fe8
leaq 0xcb88(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6760
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x6752
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6752
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6760
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x6795
movq %rax, %rbx
testb %r14b, %r14b
je 0x6795
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6795
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x679d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x67ab
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isnil(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::_isnil(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isnil() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x681e
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4c7c
movl %eax, %r14d
testb %al, %al
je 0x6868
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd029(%rip), %rsi      # 0x13829
leaq 0xd023(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x6870
movq 0x137c3(%rip), %r14     # 0x19fe8
leaq 0xca4c(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x689c
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x688e
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x688e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x689c
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x68d1
movq %rax, %rbx
testb %r14b, %r14b
je 0x68d1
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68d1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x68d9
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x68e7
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isstr(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::_isstr(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isstr() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x695a
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4e36
movl %eax, %r14d
testb %al, %al
je 0x69a4
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xceed(%rip), %rsi      # 0x13829
leaq 0xcee7(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x69ac
movq 0x13687(%rip), %r14     # 0x19fe8
leaq 0xc910(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x69d8
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x69ca
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69ca
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x69d8
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x6a0d
movq %rax, %rbx
testb %r14b, %r14b
je 0x6a0d
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a0d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x6a15
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6a23
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_issymb(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::_issymb(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->issymb() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x6a96
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4ef8
movl %eax, %r14d
testb %al, %al
je 0x6ae0
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xcdb1(%rip), %rsi      # 0x13829
leaq 0xcdab(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x6ae8
movq 0x1354b(%rip), %r14     # 0x19fe8
leaq 0xc7d4(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6b14
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x6b06
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b06
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6b14
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x6b49
movq %rax, %rbx
testb %r14b, %r14b
je 0x6b49
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b49
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x6b51
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6b5f
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x6bd2
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4fb8
movl %eax, %r14d
testb %al, %al
je 0x6c1c
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xcc75(%rip), %rsi      # 0x13829
leaq 0xcc6f(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x6c24
movq 0x1340f(%rip), %r14     # 0x19fe8
leaq 0xc698(%rip), %rsi      # 0x13278
movl $0x18, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6c50
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x6c42
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c42
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6c50
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x6c85
movq %rax, %rbx
testb %r14b, %r14b
je 0x6c85
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c85
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x6c8d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6c9b
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x72de
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x634a
jmp 0x7326
movq 0x12d03(%rip), %r14     # 0x19fe8
leaq 0xc044(%rip), %rsi      # 0x13330
movl $0x1f, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x7391
movq 0x12c2d(%rip), %rdi     # 0x19f88
leaq 0xbfc1(%rip), %rsi      # 0x13323
movl $0x7, %edx
callq 0x3210
movq (%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%r15), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x73df
movq 0x12bf9(%rip), %rcx     # 0x19f80
cmpb $0x0, (%rcx)
je 0x73db
incl 0x8(%rax)
jmp 0x73df
movq 0x12c50(%rip), %r14     # 0x19fe8
leaq 0xbf62(%rip), %rsi      # 0x13301
movl $0x21, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x7452
lock
incl 0x8(%rax)
movq 0x12ba2(%rip), %rdi     # 0x19f88
leaq -0x30(%rbp), %rsi
callq 0xa8f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x7427
callq 0x4114
movq (%r15), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x634a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf8dd
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7452
callq 0x4114
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
jmp 0x7472
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x747c
callq 0x4114
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x48(%rbp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0x7b78
movq 0x12416(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7b74
incl 0x8(%rbx)
jmp 0x7b78
lock
incl 0x8(%rbx)
leaq -0x58(%rbp), %r12
leaq -0x40(%rbp), %r14
movq %r15, %rdi
callq 0x4c7c
testb %al, %al
jne 0x7c3b
movq %r12, %rdi
movq %r15, %rsi
callq 0x634a
movq 0x123e6(%rip), %rdi     # 0x19f88
movq %r12, %rsi
callq 0xa8f0
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x627a
movq -0x40(%rbp), %rdi
callq 0x4c7c
testb %al, %al
leaq 0xb9b8(%rip), %rsi      # 0x13582
leaq 0xbb98(%rip), %rax      # 0x13769
cmovneq %rax, %rsi
movl $0x1, %edx
movq %r13, %rdi
callq 0x3210
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7bf0
callq 0x4114
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x7bfe
callq 0x4114
movq %r14, %rdi
movq %r15, %rsi
callq 0x627a
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %rbx, %rbx
je 0x7c25
movq %rbx, %rdi
callq 0x4114
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7c33
callq 0x4114
movq %r13, %rbx
jmp 0x7b80
movq -0x48(%rbp), %rdi
callq 0x51b8
testq %rbx, %rbx
je 0x7c51
movq %rbx, %rdi
callq 0x4114
movq -0x48(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7c90
jmp 0x7c90
jmp 0x7c6a
movq %rax, %r14
jmp 0x7c80
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7c80
callq 0x4114
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x7c93
callq 0x4114
jmp 0x7c93
movq %rax, %r14
testq %rbx, %rbx
je 0x7ca0
movq %rbx, %rdi
callq 0x4114
movq %r14, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0x7cdd
movq 0x122b1(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7cd9
incl 0x8(%rbx)
jmp 0x7cdd
lock
incl 0x8(%rbx)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
callq 0x4c7c
testb %al, %al
jne 0x7d51
movq %r12, %rdi
movq %r15, %rsi
callq 0x634a
movq -0x50(%rbp), %rdi
callq 0x4c7c
movl %eax, %r13d
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7d12
callq 0x4114
testb %r13b, %r13b
jne 0x7d93
movq %r12, %rdi
movq %r15, %rsi
callq 0x627a
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %rbx, %rbx
je 0x7d3e
movq %rbx, %rdi
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7d4c
callq 0x4114
movq %r13, %rbx
jmp 0x7ce1
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbac9(%rip), %rsi      # 0x13829
leaq 0xbac3(%rip), %rdx      # 0x1382a
leaq -0x50(%rbp), %rdi
callq 0x6ca4
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x51e2
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7d9b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7d9b
movq %r14, %rdi
callq 0x51b8
testq %rbx, %rbx
je 0x7da8
movq %rbx, %rdi
callq 0x4114
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7def
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7df2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7df2
jmp 0x7def
jmp 0x7def
jmp 0x7def
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7df2
callq 0x4114
jmp 0x7df2
movq %rax, %r14
testq %rbx, %rbx
je 0x7dff
movq %rbx, %rdi
callq 0x4114
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0x7e3d
movq 0x12151(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7e39
incl 0x8(%rbx)
jmp 0x7e3d
lock
incl 0x8(%rbx)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
callq 0x4c7c
testb %al, %al
jne 0x7eb1
movq %r12, %rdi
movq %r15, %rsi
callq 0x634a
movq -0x50(%rbp), %rdi
callq 0x4c7c
movl %eax, %r13d
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7e72
callq 0x4114
testb %r13b, %r13b
je 0x7ebb
movq %r12, %rdi
movq %r15, %rsi
callq 0x627a
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %rbx, %rbx
je 0x7e9e
movq %rbx, %rdi
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7eac
callq 0x4114
movq %r13, %rbx
jmp 0x7e41
movq %r14, %rdi
callq 0x51b8
jmp 0x7efb
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xb95f(%rip), %rsi      # 0x13829
leaq 0xb959(%rip), %rdx      # 0x1382a
leaq -0x50(%rbp), %rdi
callq 0x6ca4
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x51e2
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7efb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
testq %rbx, %rbx
je 0x7f08
movq %rbx, %rdi
callq 0x4114
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7f52
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7f52
jmp 0x7f4f
jmp 0x7f4f
jmp 0x7f4f
jmp 0x7f4f
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7f52
callq 0x4114
jmp 0x7f52
movq %rax, %r14
testq %rbx, %rbx
je 0x7f5f
movq %rbx, %rdi
callq 0x4114
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x7fd2
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rdi
callq 0x4c7c
movl %eax, %r14d
testb %al, %al
je 0x801c
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xb875(%rip), %rsi      # 0x13829
leaq 0xb86f(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6ca4
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
jmp 0x8024
movq 0x1200f(%rip), %r14     # 0x19fe8
leaq 0xb389(%rip), %rsi      # 0x13369
movl $0x20, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x8050
movq %rbx, %rdi
callq 0x51b8
testb %r14b, %r14b
je 0x8042
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8042
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x8050
callq 0x4114
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r14b
jmp 0x8085
movq %rax, %rbx
testb %r14b, %r14b
je 0x8085
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8085
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
testb %r14b, %r14b
jmp 0x808d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x809b
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0x8605
movq (%r15), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x634a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf8dd
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x864d
callq 0x4114
jmp 0x864d
movq 0x119dc(%rip), %r14     # 0x19fe8
leaq 0xae40(%rip), %rsi      # 0x13453
movl $0x20, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x866c
callq 0x4114
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x893e
movq 0x11652(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x8939
incl 0x8(%r15)
jmp 0x893e
lock
incl 0x8(%r15)
leaq -0x38(%rbp), %rdi
callq 0x51b8
leaq -0x70(%rbp), %r13
leaq -0x50(%rbp), %r14
movq %r12, %rdi
callq 0x4c7c
testb %al, %al
jne 0x89f6
movq %r13, %rdi
movq %r12, %rsi
callq 0x634a
movq %r14, %rdi
movq %r13, %rsi
movq -0x60(%rbp), %rdx
callq 0xf8dd
movaps -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movups %xmm0, -0x38(%rbp)
testq %rdi, %rdi
je 0x8996
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x89a4
callq 0x4114
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x89b2
callq 0x4114
cmpq $0x0, -0x38(%rbp)
je 0x8a19
movq %r14, %rdi
movq %r12, %rsi
callq 0x627a
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %r15, %r15
je 0x89e0
movq %r15, %rdi
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x89ee
callq 0x4114
movq %rbx, %r15
jmp 0x894f
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rdx
movq %rax, (%rdx)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq -0x30(%rbp), %rcx
movq %rax, -0x30(%rbp)
movq %rcx, 0x8(%rdx)
movq %rax, -0x38(%rbp)
jmp 0x8a23
xorps %xmm0, %xmm0
movq -0x58(%rbp), %rax
movups %xmm0, (%rax)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x8a31
callq 0x4114
testq %r15, %r15
je 0x8a3e
movq %r15, %rdi
callq 0x4114
movq -0x58(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8a7e
jmp 0x8a6d
jmp 0x8a6d
movq %rax, %r14
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x8a70
callq 0x4114
jmp 0x8a70
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x8a7e
callq 0x4114
testq %r15, %r15
je 0x8a8b
movq %r15, %rdi
callq 0x4114
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/include/sexpr.hpp
// Function: operator<<(std::ostream&, std::shared_ptr<sexpr>)
ostream& operator<<(ostream& os, sexpr_t expr) {
        if (not expr) os << "(null)"; // this is for debug,
                                      // should be empty string
        else if (expr->isnil()) os << "nil";
        else if (expr->isnum()) os << any_cast<sexpr_number>(*expr->blob).n;
        else if (expr->iscons()) os << any_cast<sexpr_conslist *>(*expr->blob);
        else if (expr->islambda()) os << any_cast<sexpr_lambda>(*expr->blob);
        else os << any_cast<sexpr_text>(*expr->blob).text();
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xa927
movq %rsi, %r14
callq 0x4c7c
testb %al, %al
je 0xa94e
leaq 0x8c5a(%rip), %rsi      # 0x1357a
movl $0x3, %edx
jmp 0xa933
leaq 0x8c45(%rip), %rsi      # 0x13573
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3210
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
callq 0x4dfa
movq (%r14), %rdi
testb %al, %al
je 0xa97c
movq (%rdi), %rdi
callq 0xaf0f
testq %rax, %rax
je 0xaa93
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x32d0
jmp 0xa93b
callq 0x4cb8
movq (%r14), %rdi
testb %al, %al
je 0xa9a6
movq (%rdi), %rdi
callq 0x5100
testq %rax, %rax
je 0xaa93
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xaaf3
jmp 0xa93b
callq 0x4fb8
testb %al, %al
je 0xaa06
movq (%r14), %rax
movq (%rax), %rsi
leaq -0xc8(%rbp), %r14
movq %r14, %rdi
callq 0xae15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xace2
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x4014
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa9ec
callq 0x4114
movq -0xc0(%rbp), %rdi
testq %rdi, %rdi
je 0xa93b
callq 0x4114
jmp 0xa93b
movq (%r14), %rax
movq (%rax), %rdi
callq 0x4695
movq %rax, %r14
testq %rax, %rax
je 0xaa93
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x45ce
movb 0x20(%r14), %al
movb %al, 0x20(%r15)
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x38ac
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x3210
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa75
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa93b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xa93b
callq 0x4667
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaab9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xaab9
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xaae1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xaae1
jmp 0xaaeb
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x5a14
movq %rbx, %rdi
callq 0x3310
jmp 0xaaeb
movq %rax, %rdi
callq 0x4085
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a6d(%rip), %rsi      # 0x1357e
movl $0x1, %edx
callq 0x3210
movq (%r14), %rax
movq %rax, -0x60(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0xab44
movq 0xf44a(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xab40
incl 0x8(%rax)
jmp 0xab44
lock
incl 0x8(%rax)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0xa8f0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xab5e
callq 0x4114
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
testq %r12, %r12
je 0xab84
movq 0xf40e(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xab7e
incl 0x8(%r12)
jmp 0xab84
lock
incl 0x8(%r12)
leaq -0x70(%rbp), %r13
movq %r15, %rdi
callq 0x4c7c
testb %al, %al
jne 0xac6e
movq %r15, %rdi
callq 0x4dc4
testb %al, %al
jne 0xac1a
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x89cf(%rip), %rsi      # 0x13582
callq 0x3210
movq %r13, %rdi
movq %r15, %rsi
callq 0x634a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa8f0
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0xabdc
callq 0x4114
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x627a
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %r12, %r12
je 0xac04
movq %r12, %rdi
callq 0x4114
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xac12
callq 0x4114
movq %r14, %r12
jmp 0xab88
leaq 0x895f(%rip), %rsi      # 0x13580
movl $0x3, %edx
movq %rbx, %rdi
callq 0x3210
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
testq %r12, %r12
je 0xac54
movq 0xf33e(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xac4e
incl 0x8(%r12)
jmp 0xac54
lock
incl 0x8(%r12)
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xa8f0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xac6e
callq 0x4114
testq %r12, %r12
je 0xac7b
movq %r12, %rdi
callq 0x4114
leaq 0x8da4(%rip), %rsi      # 0x13a26
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3210
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0xacbc
jmp 0xacca
movq %rax, %rbx
movq -0x58(%rbp), %r12
jmp 0xaccd
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0xaccd
callq 0x4114
jmp 0xaccd
jmp 0xacca
movq %rax, %rbx
testq %r12, %r12
je 0xacda
movq %r12, %rdi
callq 0x4114
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x58(%rsi)
je 0xad12
leaq 0x8884(%rip), %rsi      # 0x13584
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3210
jmp 0xaddb
movq %rsi, %r14
leaq 0x8873(%rip), %rsi      # 0x1358f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3210
movq (%r14), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0xad52
movq 0xf23c(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xad4e
incl 0x8(%rax)
jmp 0xad52
lock
incl 0x8(%rax)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xa8f0
movq %rax, %r15
leaq 0x882f(%rip), %rsi      # 0x13597
movl $0x8, %edx
movq %rax, %rdi
callq 0x3210
movq 0x10(%r14), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%r14), %rax
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0xad9f
movq 0xf1ef(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xad9b
incl 0x8(%rax)
jmp 0xad9f
lock
incl 0x8(%rax)
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0xa8f0
leaq 0x87db(%rip), %rsi      # 0x1358d
movl $0x1, %edx
movq %rax, %rdi
callq 0x3210
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xadcd
callq 0x4114
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xaddb
callq 0x4114
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xadff
callq 0x4114
jmp 0xadff
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xae0d
callq 0x4114
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x2, %rax
jne 0xb760
movq (%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x634a
movq (%r14), %rsi
leaq -0x20(%rbp), %rdi
callq 0x627a
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x634a
leaq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x52f5
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb742
callq 0x4114
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb750
callq 0x4114
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb7a8
callq 0x4114
jmp 0xb7a8
movq 0xe881(%rip), %r14      # 0x19fe8
leaq 0x7e32(%rip), %rsi      # 0x135a0
movl $0x2c, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb7ca
callq 0x4114
jmp 0xb7ca
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb7dd
callq 0x4114
jmp 0xb7dd
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb7eb
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/0x0584[P]scmin-plus/src/builtin/cons.cpp
// Function: builtin::_car(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::_car(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "car expects only one argument" << endl;
        return nullptr;
    }
    if (not (args->car()->islist() or args->car()->ispair())) {
        // cerr << args << endl;
        cerr << "car is applicable only on conslists" << endl;
        return nullptr;
    }
    return args->car()->car();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4ff4
cmpq $0x1, %rax
jne 0xb8a4
movq (%r14), %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x634a
movq (%r15), %rdi
callq 0x4cf4
movl %eax, %r12d
movb $0x1, %r15b
testb %al, %al
jne 0xb854
movq (%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x634a
movq -0x40(%rbp), %rdi
callq 0x4d5c
movl %eax, %r15d
testb %r12b, %r12b
jne 0xb867
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb867
callq 0x4114
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb875
callq 0x4114
testb %r15b, %r15b
je 0xb8b9
movq (%r14), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x634a
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x634a
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb901
callq 0x4114
jmp 0xb901
movq 0xe73d(%rip), %r14      # 0x19fe8
leaq 0x7d1b(%rip), %rsi      # 0x135cd
movl $0x1d, %edx
jmp 0xb8cc
movq 0xe728(%rip), %r14      # 0x19fe8
leaq 0x7d24(%rip), %rsi      # 0x135eb
movl $0x23, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb928
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb92b
callq 0x4114
jmp 0xb92b
jmp 0xb928
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb939
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop