LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: cons_append(std::shared_ptr<sexpr> const&, std::shared_ptr<sexpr>&, std::shared_ptr<sexpr>&)
bool cons_append(const sexpr_t& e, sexpr_t& expr, sexpr_t& tail) {
    if (e == nullptr)
        return false;
    if (not expr)
        tail = expr = cons(e, nil());
    else {
        tail->setcdr(cons(e, nil()));
        tail = tail->cdr();
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0x6119
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rsi)
je 0x60a5
movq (%rbx), %r14
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x514c
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5289
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x615c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6074
callq 0x4104
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6082
callq 0x4104
movq (%rbx), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x61be
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
movq %rcx, 0x8(%rbx)
jmp 0x610f
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x514c
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5289
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rax, (%r14)
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq %rcx, 0x8(%r14)
testq %rdi, %rdi
je 0x60eb
callq 0x4104
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62fc
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x610b
callq 0x4104
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6119
callq 0x4104
testq %r13, %r13
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6143
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6146
callq 0x4104
jmp 0x6146
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6154
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcdr(std::shared_ptr<sexpr> const&)
bool sexpr::setcdr(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->cdr = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4d54
testb %al, %al
jne 0x617e
movq %r14, %rdi
callq 0x4cec
testb %al, %al
je 0x61a9
movq (%r14), %rdi
callq 0x5093
testq %rax, %rax
je 0x61b0
movq (%rax), %rdi
movq (%rbx), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x62fc
movb $0x1, %al
jmp 0x61ab
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4668
movq %rax, %rdi
callq 0x4075
nop
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcar(std::shared_ptr<sexpr> const&)
bool sexpr::setcar(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->car = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4d54
testb %al, %al
jne 0x6250
movq %r14, %rdi
callq 0x4cec
testb %al, %al
je 0x627a
movq (%r14), %rdi
callq 0x5093
testq %rax, %rax
je 0x6281
movq (%rax), %rdi
movq (%rbx), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x62fc
movb $0x1, %al
jmp 0x627c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4668
movq %rax, %rdi
callq 0x4075
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x63c8
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4d54
testb %al, %al
je 0x6412
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd494(%rip), %rsi      # 0x13829
leaq 0xd48e(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x641a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x641a
movq 0x13c19(%rip), %r14     # 0x19fe8
leaq 0xcea2(%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 0x6428
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6428
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6455
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6455
jmp 0x6452
jmp 0x6452
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6463
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x64ec
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4cec
testb %al, %al
je 0x6536
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd370(%rip), %rsi      # 0x13829
leaq 0xd36a(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x653e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x653e
movq 0x13af5(%rip), %r14     # 0x19fe8
leaq 0xcd7e(%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 0x654c
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x654c
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6579
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6579
jmp 0x6576
jmp 0x6576
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6587
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x6610
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4df2
testb %al, %al
je 0x665a
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd24c(%rip), %rsi      # 0x13829
leaq 0xd246(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6662
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6662
movq 0x139d1(%rip), %r14     # 0x19fe8
leaq 0xcc5a(%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 0x6670
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6670
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x669d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x669d
jmp 0x669a
jmp 0x669a
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x66ab
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x6734
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4c74
testb %al, %al
je 0x677e
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd128(%rip), %rsi      # 0x13829
leaq 0xd122(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6786
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6786
movq 0x138ad(%rip), %r14     # 0x19fe8
leaq 0xcb36(%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 0x6794
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6794
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x67c1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x67c1
jmp 0x67be
jmp 0x67be
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x67cf
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x6858
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4e2e
testb %al, %al
je 0x68a2
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd004(%rip), %rsi      # 0x13829
leaq 0xcffe(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x68aa
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x68aa
movq 0x13789(%rip), %r14     # 0x19fe8
leaq 0xca12(%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 0x68b8
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x68b8
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x68e5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x68e5
jmp 0x68e2
jmp 0x68e2
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x68f3
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x697c
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4ed6
testb %al, %al
je 0x69c6
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xcee0(%rip), %rsi      # 0x13829
leaq 0xceda(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x69ce
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x69ce
movq 0x13665(%rip), %r14     # 0x19fe8
leaq 0xc8ee(%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 0x69dc
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x69dc
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6a09
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6a09
jmp 0x6a06
jmp 0x6a06
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6a17
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x6aa0
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4f7a
testb %al, %al
je 0x6aea
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xcdbc(%rip), %rsi      # 0x13829
leaq 0xcdb6(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6af2
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6af2
movq 0x13541(%rip), %r14     # 0x19fe8
leaq 0xc7ca(%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 0x6b00
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6b00
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6b2d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x6b2d
jmp 0x6b2a
jmp 0x6b2a
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6b3b
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x7116
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x628e
jmp 0x715e
movq 0x12ecb(%rip), %r14     # 0x19fe8
leaq 0xc20c(%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_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x71c9
movq 0x12df5(%rip), %rdi     # 0x19f88
leaq 0xc189(%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 0x7217
movq 0x12dc1(%rip), %rcx     # 0x19f80
cmpb $0x0, (%rcx)
je 0x7213
incl 0x8(%rax)
jmp 0x7217
movq 0x12e18(%rip), %r14     # 0x19fe8
leaq 0xc12a(%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 0x728a
lock
incl 0x8(%rax)
movq 0x12d6a(%rip), %rdi     # 0x19f88
leaq -0x30(%rbp), %rsi
callq 0xa61c
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 0x725f
callq 0x4104
movq (%r15), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x628e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf373
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x728a
callq 0x4104
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 0x72aa
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x72b4
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7948
movq 0x12646(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7944
incl 0x8(%rbx)
jmp 0x7948
lock
incl 0x8(%rbx)
leaq -0x58(%rbp), %r12
leaq -0x40(%rbp), %r14
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0x7a0b
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq 0x12616(%rip), %rdi     # 0x19f88
movq %r12, %rsi
callq 0xa61c
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x61be
movq -0x40(%rbp), %rdi
callq 0x4c74
testb %al, %al
leaq 0xbbe8(%rip), %rsi      # 0x13582
leaq 0xbdc8(%rip), %rax      # 0x13769
cmovneq %rax, %rsi
movl $0x1, %edx
movq %r13, %rdi
callq 0x3210
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x79c0
callq 0x4104
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x79ce
callq 0x4104
movq %r14, %rdi
movq %r15, %rsi
callq 0x61be
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %rbx, %rbx
je 0x7a03
movq %rbx, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7a03
callq 0x4104
movq %r13, %rbx
jmp 0x7950
movq -0x48(%rbp), %rdi
callq 0x514c
testq %rbx, %rbx
je 0x7a21
movq %rbx, %rdi
callq 0x4104
movq -0x48(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a60
jmp 0x7a60
jmp 0x7a3a
movq %rax, %r14
jmp 0x7a50
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7a50
callq 0x4104
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x7a63
callq 0x4104
jmp 0x7a63
movq %rax, %r14
testq %rbx, %rbx
je 0x7a70
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7aad
movq 0x124e1(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7aa9
incl 0x8(%rbx)
jmp 0x7aad
lock
incl 0x8(%rbx)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0x7b21
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x50(%rbp), %rdi
callq 0x4c74
movl %eax, %r13d
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7ae2
callq 0x4104
testb %r13b, %r13b
jne 0x7b63
movq %r12, %rdi
movq %r15, %rsi
callq 0x61be
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %rbx, %rbx
je 0x7b1c
movq %rbx, %rdi
callq 0x4104
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7b1c
callq 0x4104
movq %r13, %rbx
jmp 0x7ab1
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbcf9(%rip), %rsi      # 0x13829
leaq 0xbcf3(%rip), %rdx      # 0x1382a
leaq -0x50(%rbp), %rdi
callq 0x6b44
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x5176
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7b6b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7b6b
movq %r14, %rdi
callq 0x514c
testq %rbx, %rbx
je 0x7b78
movq %rbx, %rdi
callq 0x4104
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7bbf
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7bc2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7bc2
jmp 0x7bbf
jmp 0x7bbf
jmp 0x7bbf
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7bc2
callq 0x4104
jmp 0x7bc2
movq %rax, %r14
testq %rbx, %rbx
je 0x7bcf
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7c0d
movq 0x12381(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x7c09
incl 0x8(%rbx)
jmp 0x7c0d
lock
incl 0x8(%rbx)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0x7c81
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x50(%rbp), %rdi
callq 0x4c74
movl %eax, %r13d
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7c42
callq 0x4104
testb %r13b, %r13b
je 0x7c8b
movq %r12, %rdi
movq %r15, %rsi
callq 0x61be
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %rbx, %rbx
je 0x7c7c
movq %rbx, %rdi
callq 0x4104
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7c7c
callq 0x4104
movq %r13, %rbx
jmp 0x7c11
movq %r14, %rdi
callq 0x514c
jmp 0x7ccb
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbb8f(%rip), %rsi      # 0x13829
leaq 0xbb89(%rip), %rdx      # 0x1382a
leaq -0x50(%rbp), %rdi
callq 0x6b44
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x5176
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x7ccb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
testq %rbx, %rbx
je 0x7cd8
movq %rbx, %rdi
callq 0x4104
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 0x7d22
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7d22
jmp 0x7d1f
jmp 0x7d1f
jmp 0x7d1f
jmp 0x7d1f
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x7d22
callq 0x4104
jmp 0x7d22
movq %rax, %r14
testq %rbx, %rbx
je 0x7d2f
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x7db8
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4c74
testb %al, %al
je 0x7e02
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xbaa4(%rip), %rsi      # 0x13829
leaq 0xba9e(%rip), %rdx      # 0x1382a
leaq -0x30(%rbp), %rdi
callq 0x6b44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5176
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e0a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7e0a
movq 0x12229(%rip), %r14     # 0x19fe8
leaq 0xb5a3(%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 0x7e18
movq %rbx, %rdi
callq 0x514c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7e18
callq 0x4104
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e45
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0x7e45
jmp 0x7e42
jmp 0x7e42
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x7e53
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0x83bd
movq (%r15), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x628e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf373
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8405
callq 0x4104
jmp 0x8405
movq 0x11c24(%rip), %r14     # 0x19fe8
leaq 0xb088(%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 0x8424
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x48(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x86f6
movq 0x1189a(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x86f1
incl 0x8(%r15)
jmp 0x86f6
lock
incl 0x8(%r15)
leaq -0x58(%rbp), %rdi
callq 0x514c
leaq -0x70(%rbp), %r13
leaq -0x40(%rbp), %r14
movq %r12, %rdi
callq 0x4c74
testb %al, %al
jne 0x87ae
movq %r13, %rdi
movq %r12, %rsi
callq 0x628e
movq %r14, %rdi
movq %r13, %rsi
movq -0x60(%rbp), %rdx
callq 0xf373
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq -0x50(%rbp), %rdi
movups %xmm0, -0x58(%rbp)
testq %rdi, %rdi
je 0x875c
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x875c
callq 0x4104
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x876a
callq 0x4104
cmpq $0x0, -0x58(%rbp)
je 0x87c3
movq %r14, %rdi
movq %r12, %rsi
callq 0x61be
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %r15, %r15
je 0x87a6
movq %r15, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x87a6
callq 0x4104
movq %rbx, %r15
jmp 0x8707
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, (%rcx)
movq -0x50(%rbp), %rax
movq %rax, 0x8(%rcx)
jmp 0x87db
xorps %xmm0, %xmm0
movq -0x48(%rbp), %rax
movups %xmm0, (%rax)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x87db
callq 0x4104
testq %r15, %r15
je 0x87e8
movq %r15, %rdi
callq 0x4104
movq -0x48(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8828
jmp 0x8817
jmp 0x8817
movq %rax, %r14
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x881a
callq 0x4104
jmp 0x881a
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x8828
callq 0x4104
testq %r15, %r15
je 0x8835
movq %r15, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa653
movq %rsi, %r14
callq 0x4c74
testb %al, %al
je 0xa67a
leaq 0x8f2e(%rip), %rsi      # 0x1357a
movl $0x3, %edx
jmp 0xa65f
leaq 0x8f19(%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 0x4df2
movq (%r14), %rdi
testb %al, %al
je 0xa6a8
movq (%rdi), %rdi
callq 0xac3b
testq %rax, %rax
je 0xa7bf
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x32d0
jmp 0xa667
callq 0x4cb0
movq (%r14), %rdi
testb %al, %al
je 0xa6d2
movq (%rdi), %rdi
callq 0x5093
testq %rax, %rax
je 0xa7bf
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xa81f
jmp 0xa667
callq 0x4f7a
testb %al, %al
je 0xa732
movq (%r14), %rax
movq (%rax), %rsi
leaq -0xc8(%rbp), %r14
movq %r14, %rdi
callq 0xab41
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa0e
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x4004
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa718
callq 0x4104
movq -0xc0(%rbp), %rdi
testq %rdi, %rdi
je 0xa667
callq 0x4104
jmp 0xa667
movq (%r14), %rax
movq (%rax), %rdi
callq 0x4696
movq %rax, %r14
testq %rax, %rax
je 0xa7bf
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 0x45ca
movb 0x20(%r14), %al
movb %al, 0x20(%r15)
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x389c
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 0xa7a1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x31f0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa667
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xa667
callq 0x4668
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xa7e5
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa80d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x31f0
jmp 0xa80d
jmp 0xa817
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x5972
movq %rbx, %rdi
callq 0x3310
jmp 0xa817
movq %rax, %rdi
callq 0x4075
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d41(%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 0xa870
movq 0xf71e(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xa86c
incl 0x8(%rax)
jmp 0xa870
lock
incl 0x8(%rax)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0xa61c
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xa88a
callq 0x4104
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
testq %r12, %r12
je 0xa8b0
movq 0xf6e2(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xa8aa
incl 0x8(%r12)
jmp 0xa8b0
lock
incl 0x8(%r12)
leaq -0x70(%rbp), %r13
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0xa99a
movq %r15, %rdi
callq 0x4dbc
testb %al, %al
jne 0xa946
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x8ca3(%rip), %rsi      # 0x13582
callq 0x3210
movq %r13, %rdi
movq %r15, %rsi
callq 0x628e
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa61c
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0xa908
callq 0x4104
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x61be
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %r12, %r12
je 0xa93e
movq %r12, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xa93e
callq 0x4104
movq %r14, %r12
jmp 0xa8b4
leaq 0x8c33(%rip), %rsi      # 0x13580
movl $0x3, %edx
movq %rbx, %rdi
callq 0x3210
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
testq %r12, %r12
je 0xa980
movq 0xf612(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xa97a
incl 0x8(%r12)
jmp 0xa980
lock
incl 0x8(%r12)
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xa61c
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xa99a
callq 0x4104
testq %r12, %r12
je 0xa9a7
movq %r12, %rdi
callq 0x4104
leaq 0x9078(%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 0xa9e8
jmp 0xa9f6
movq %rax, %rbx
movq -0x58(%rbp), %r12
jmp 0xa9f9
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0xa9f9
callq 0x4104
jmp 0xa9f9
jmp 0xa9f6
movq %rax, %rbx
testq %r12, %r12
je 0xaa06
movq %r12, %rdi
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa3e
leaq 0x8b58(%rip), %rsi      # 0x13584
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3210
jmp 0xab07
movq %rsi, %r14
leaq 0x8b47(%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 0xaa7e
movq 0xf510(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xaa7a
incl 0x8(%rax)
jmp 0xaa7e
lock
incl 0x8(%rax)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xa61c
movq %rax, %r15
leaq 0x8b03(%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 0xaacb
movq 0xf4c3(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xaac7
incl 0x8(%rax)
jmp 0xaacb
lock
incl 0x8(%rax)
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0xa61c
leaq 0x8aaf(%rip), %rsi      # 0x1358d
movl $0x1, %edx
movq %rax, %rdi
callq 0x3210
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xaaf9
callq 0x4104
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xab07
callq 0x4104
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 0xab2b
callq 0x4104
jmp 0xab2b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xab39
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x2, %rax
jne 0xb470
movq (%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x628e
movq (%r14), %rsi
leaq -0x20(%rbp), %rdi
callq 0x61be
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x628e
leaq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x5289
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xb452
callq 0x4104
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb460
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb4b8
callq 0x4104
jmp 0xb4b8
movq 0xeb71(%rip), %r14      # 0x19fe8
leaq 0x8122(%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 0xb4da
callq 0x4104
jmp 0xb4da
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xb4ed
callq 0x4104
jmp 0xb4ed
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xb4fb
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop