LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x60d9
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x4a24
testb %al, %al
je 0x60fc
leaq 0xa754(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x6104
movq 0x11f08(%rip), %rdi     # 0x17fe8
leaq 0xa149(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x610d
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x612e
jmp 0x612b
jmp 0x612b
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x61a5
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x49e0
testb %al, %al
je 0x61c8
leaq 0xa688(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x61d0
movq 0x11e3c(%rip), %rdi     # 0x17fe8
leaq 0xa07d(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x61d9
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x61fa
jmp 0x61f7
jmp 0x61f7
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x6271
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x4a9e
testb %al, %al
je 0x6294
leaq 0xa5bc(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x629c
movq 0x11d70(%rip), %rdi     # 0x17fe8
leaq 0x9fb1(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x62a5
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x62c6
jmp 0x62c3
jmp 0x62c3
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x633d
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x49a8
testb %al, %al
je 0x6360
leaq 0xa4f0(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x6368
movq 0x11ca4(%rip), %rdi     # 0x17fe8
leaq 0x9ee5(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6371
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x6392
jmp 0x638f
jmp 0x638f
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x6409
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x4aba
testb %al, %al
je 0x642c
leaq 0xa424(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x6434
movq 0x11bd8(%rip), %rdi     # 0x17fe8
leaq 0x9e19(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x643d
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x645e
jmp 0x645b
jmp 0x645b
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x64d5
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x4b10
testb %al, %al
je 0x64f8
leaq 0xa358(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x6500
movq 0x11b0c(%rip), %rdi     # 0x17fe8
leaq 0x9d4d(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6509
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x652a
jmp 0x6527
jmp 0x6527
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x65a1
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x4b64
testb %al, %al
je 0x65c4
leaq 0xa28c(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x65cc
movq 0x11a40(%rip), %rdi     # 0x17fe8
leaq 0x9c81(%rip), %rsi      # 0x10230
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x65d5
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x65f6
jmp 0x65f3
jmp 0x65f3
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b80
cmpq $0x1, %rax
jne 0x6a5c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5fc6
jmp 0x6a7d
movq 0x11585(%rip), %rdi     # 0x17fe8
leaq 0x98a8(%rip), %rsi      # 0x10312
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x6b17
movq 0x114d3(%rip), %rdi     # 0x17f88
leaq 0x9849(%rip), %rsi      # 0x10305
callq 0x31f0
movq %rax, %r12
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3e44
movq %r12, %rdi
movq %r13, %rsi
callq 0x8ebe
movq %rax, %rdi
callq 0x3100
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq (%r15), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x5fc6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc9d5
leaq -0x30(%rbp), %rdi
callq 0x3e82
jmp 0x6b38
movq 0x114ca(%rip), %rdi     # 0x17fe8
leaq 0x97be(%rip), %rsi      # 0x102e3
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x6b5a
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e44
leaq -0x60(%rbp), %r14
leaq -0x48(%rbp), %r15
leaq 0x96c8(%rip), %r13      # 0x10749
leaq 0x94dc(%rip), %rbx      # 0x10564
movq -0x38(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x7111
movq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x5fc6
movq 0x10ee0(%rip), %rdi     # 0x17f88
movq %r14, %rsi
callq 0x8ebe
movq %rax, %r12
movq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x5f48
movq -0x48(%rbp), %rdi
callq 0x49a8
testb %al, %al
movq %rbx, %rsi
cmovneq %r13, %rsi
movq %r12, %rdi
callq 0x31f0
leaq -0x40(%rbp), %rdi
callq 0x3e82
leaq -0x58(%rbp), %rdi
callq 0x3e82
movq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x5f48
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4354
leaq -0x40(%rbp), %rdi
callq 0x3e82
jmp 0x7088
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d18
leaq -0x30(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x715a
jmp 0x715a
jmp 0x713e
movq %rax, %rbx
jmp 0x714f
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
leaq -0x58(%rbp), %rdi
callq 0x3e82
jmp 0x715d
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, -0x38(%rbp)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3e44
leaq -0x60(%rbp), %r14
leaq -0x60(%rbp), %r12
leaq -0x68(%rbp), %r13
movq -0x48(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x71ec
movq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x5fc6
movq -0x68(%rbp), %rdi
callq 0x49a8
movl %eax, %ebx
movq %r14, %rdi
callq 0x3e82
testb %bl, %bl
jne 0x721b
movq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x5f48
movq %r15, %rdi
movq %r13, %rsi
callq 0x4354
movq %r12, %rdi
callq 0x3e82
jmp 0x719b
leaq 0x9616(%rip), %rsi      # 0x10809
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x6608
leaq -0x68(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d30
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x7227
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d18
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7265
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x7268
jmp 0x7265
jmp 0x7265
jmp 0x7265
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e82
jmp 0x7268
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, -0x38(%rbp)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3e44
leaq -0x60(%rbp), %r14
leaq -0x60(%rbp), %r12
leaq -0x68(%rbp), %r13
movq -0x48(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x72f8
movq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x5fc6
movq -0x68(%rbp), %rdi
callq 0x49a8
movl %eax, %ebx
movq %r14, %rdi
callq 0x3e82
testb %bl, %bl
je 0x7306
movq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x5f48
movq %r15, %rdi
movq %r13, %rsi
callq 0x4354
movq %r12, %rdi
callq 0x3e82
jmp 0x72a7
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d18
jmp 0x7333
leaq 0x94fc(%rip), %rsi      # 0x10809
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x6608
leaq -0x68(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d30
leaq -0x68(%rbp), %rdi
callq 0x30f0
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x7374
jmp 0x7371
jmp 0x7371
jmp 0x7371
jmp 0x7371
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e82
jmp 0x7374
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x73eb
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rdi
callq 0x49a8
testb %al, %al
je 0x740e
leaq 0x9442(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x7416
movq 0x10bf6(%rip), %rdi     # 0x17fe8
leaq 0x8f52(%rip), %rsi      # 0x1034b
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x741f
movq %rbx, %rdi
callq 0x4d18
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x7440
jmp 0x743d
jmp 0x743d
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_set(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::_set(const sexpr_t& args, env_t& bindings) {
    if (args->length() != 2) {
        cerr << "Err: expecting two arguments!" << endl;
        return nil();
    }
    if (not args->car()->issymb()) {
        cerr << "Err: cannot set constant values!" << endl;
        return nil();
    }
    auto itr = bindings.find(any_cast<sexpr_text>(*args->car()->blob).text());
    if (itr == end(bindings)) {
        cerr << "Err: symbol is not defined, use define instead" << endl;
        return nil();
    }
    itr->second = ::eval(args->cdr()->car(), bindings);
    return itr->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x2, %rax
jne 0x756b
movq (%r15), %rsi
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x5fc6
movq (%r12), %rdi
callq 0x4b10
movl %eax, %r12d
leaq -0x50(%rbp), %rdi
callq 0x3e82
testb %r12b, %r12b
je 0x757b
movq (%r15), %rsi
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x5fc6
movq (%r12), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3d07
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x37cc
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x9438
movq %rax, %r12
leaq -0x78(%rbp), %rdi
callq 0x30f0
leaq -0x58(%rbp), %rdi
callq 0x30f0
leaq -0x28(%rbp), %rdi
callq 0x3e82
testq %r12, %r12
je 0x758b
movq (%r15), %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x5f48
movq (%r15), %rsi
leaq -0x78(%rbp), %rdi
callq 0x5fc6
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %r14, %rdx
callq 0xc9d5
addq $0x28, %r12
leaq -0x58(%rbp), %rsi
movq %r12, %rdi
callq 0x4354
leaq -0x50(%rbp), %rdi
callq 0x3e82
leaq -0x70(%rbp), %rdi
callq 0x3e82
leaq -0x28(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e44
jmp 0x75ae
movq 0x10a76(%rip), %rdi     # 0x17fe8
leaq 0x8df3(%rip), %rsi      # 0x1036c
jmp 0x7599
movq 0x10a66(%rip), %rdi     # 0x17fe8
leaq 0x8e01(%rip), %rsi      # 0x1038a
jmp 0x7599
movq 0x10a56(%rip), %rdi     # 0x17fe8
leaq 0x8e12(%rip), %rsi      # 0x103ab
callq 0x31f0
movq %rax, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x4d18
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3e82
jmp 0x75ed
jmp 0x75ea
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x30f0
jmp 0x75df
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30f0
jmp 0x75ed
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
jmp 0x75fa
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/builtin/builtin.cpp
// Function: builtin::_unset(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::_unset(const sexpr_t& args, env_t& bindings) {
    if (args->length() != 1) {
        cerr << "Err: expecting one argument!" << endl;
        return nil();
    }
    if (not args->car()->issymb()) {
        cerr << "Err: cannot unset constant values!" << endl;
        return nil();
    }
    auto itr = bindings.find(any_cast<sexpr_text>(*args->car()->blob).text());
    if (itr == end(bindings)) {
        cerr << "Err: symbol is not defined" << endl;
        return nil();
    }
    bindings.erase(itr);
    return symb("t");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x76ef
movq (%r15), %rsi
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x5fc6
movq (%r12), %rdi
callq 0x4b10
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x3e82
testb %r12b, %r12b
je 0x76ff
movq (%r15), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x5fc6
movq (%r15), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3d07
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x37cc
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x9438
movq %rax, %r15
leaq -0x78(%rbp), %rdi
callq 0x30f0
leaq -0x48(%rbp), %rdi
callq 0x30f0
leaq -0x50(%rbp), %rdi
callq 0x3e82
testq %r15, %r15
je 0x770f
movq %r14, %rdi
movq %r15, %rsi
callq 0x95be
leaq 0x913e(%rip), %rsi      # 0x10809
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x6608
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d30
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x7732
movq 0x108f2(%rip), %rdi     # 0x17fe8
leaq 0x8cdd(%rip), %rsi      # 0x103da
jmp 0x771d
movq 0x108e2(%rip), %rdi     # 0x17fe8
leaq 0x8cea(%rip), %rsi      # 0x103f7
jmp 0x771d
movq 0x108d2(%rip), %rdi     # 0x17fe8
leaq 0x8cfd(%rip), %rsi      # 0x1041a
callq 0x31f0
movq %rax, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x4d18
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x7786
movq %rax, %rbx
jmp 0x7786
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x30f0
jmp 0x7766
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30f0
jmp 0x7774
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x7781
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b80
cmpq $0x1, %rax
jne 0x77da
movq (%r15), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x5fc6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc9d5
leaq -0x20(%rbp), %rdi
callq 0x3e82
jmp 0x77fb
movq 0x10807(%rip), %rdi     # 0x17fe8
leaq 0x8c4d(%rip), %rsi      # 0x10435
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3e44
leaq -0x38(%rbp), %rdi
callq 0x4d18
leaq -0x60(%rbp), %rbx
leaq -0x70(%rbp), %r15
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %r12
movq -0x48(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x7acd
movq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x5fc6
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc9d5
movq %r13, %rdi
movq %r15, %rsi
callq 0x4354
leaq -0x68(%rbp), %rdi
callq 0x3e82
leaq -0x58(%rbp), %rdi
callq 0x3e82
cmpq $0x0, -0x38(%rbp)
je 0x7aec
movq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x5f48
movq %r12, %rdi
movq %r15, %rsi
callq 0x4354
leaq -0x68(%rbp), %rdi
callq 0x3e82
jmp 0x7a60
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rbx
movq %rax, (%rbx)
movq -0x30(%rbp), %rax
andq $0x0, -0x30(%rbp)
movq %rax, 0x8(%rbx)
andq $0x0, -0x38(%rbp)
jmp 0x7af6
xorps %xmm0, %xmm0
movq -0x50(%rbp), %rbx
movups %xmm0, (%rbx)
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7b3d
jmp 0x7b31
jmp 0x7b31
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3e82
jmp 0x7b34
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x8eec
movq %rsi, %r14
callq 0x49a8
testb %al, %al
je 0x8f0a
leaq 0x7672(%rip), %rsi      # 0x1055c
jmp 0x8ef3
leaq 0x7662(%rip), %rsi      # 0x10555
movq %rbx, %rdi
callq 0x31f0
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
callq 0x4a9e
movq (%r14), %rdi
testb %al, %al
je 0x8f2b
movq (%rdi), %rdi
callq 0x900a
movq %rbx, %rdi
callq 0x32d0
jmp 0x8efb
callq 0x49c4
movq (%r14), %rdi
testb %al, %al
je 0x8f4c
movq (%rdi), %rdi
callq 0x4c41
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9023
jmp 0x8efb
callq 0x4b64
testb %al, %al
je 0x8f86
movq (%r14), %rax
movq (%rax), %rsi
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
callq 0x9271
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9192
leaq -0xb8(%rbp), %rdi
callq 0x57a2
jmp 0x8efb
movq (%r14), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x3d07
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x37cc
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
callq 0x30f0
leaq -0x58(%rbp), %rdi
callq 0x30f0
jmp 0x8efb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30f0
jmp 0x8fd8
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30f0
jmp 0x8ff2
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x57a2
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x751f(%rip), %rsi      # 0x10560
callq 0x31f0
movq %rax, %r15
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e44
movq %r15, %rdi
movq %r12, %rsi
callq 0x8ebe
leaq -0x60(%rbp), %rdi
callq 0x3e82
addq $0x10, %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x3e44
leaq 0x74e1(%rip), %r13      # 0x10564
leaq -0x58(%rbp), %r14
leaq -0x78(%rbp), %r12
movq -0x38(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x9130
movq -0x38(%rbp), %rdi
callq 0x4a68
testb %al, %al
jne 0x90fa
movq %rbx, %rdi
movq %r13, %rsi
callq 0x31f0
movq %rax, %r15
movq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x5fc6
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ebe
leaq -0x50(%rbp), %rdi
callq 0x3e82
movq -0x38(%rbp), %rsi
movq %r12, %rdi
callq 0x5f48
leaq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x4354
leaq -0x70(%rbp), %rdi
callq 0x3e82
jmp 0x908b
leaq 0x7461(%rip), %rsi      # 0x10562
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r14
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x3e44
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ebe
leaq -0x40(%rbp), %rdi
callq 0x3e82
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq 0x78ba(%rip), %rsi      # 0x109fa
movq %rbx, %rdi
callq 0x31f0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x9175
jmp 0x917e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x9185
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3e82
jmp 0x9181
jmp 0x917e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x58(%rsi)
je 0x91bf
leaq 0x73b4(%rip), %rsi      # 0x10566
movq %rbx, %rdi
callq 0x31f0
jmp 0x923f
movq %rsi, %r14
leaq 0x73a8(%rip), %rsi      # 0x10571
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e44
movq %r15, %rdi
movq %r12, %rsi
callq 0x8ebe
leaq 0x7384(%rip), %rsi      # 0x10579
movq %rax, %rdi
callq 0x31f0
movq %rax, %r15
addq $0x10, %r14
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e44
movq %r15, %rdi
movq %r12, %rsi
callq 0x8ebe
leaq 0x734a(%rip), %rsi      # 0x1056f
movq %rax, %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x3e82
leaq -0x38(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3e82
jmp 0x9260
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b80
cmpq $0x2, %rax
jne 0x9b81
movq (%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5fc6
movq (%r14), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5f48
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5fc6
leaq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x4dd5
leaq -0x28(%rbp), %rdi
callq 0x3e82
leaq -0x18(%rbp), %rdi
callq 0x3e82
leaq -0x38(%rbp), %rdi
callq 0x3e82
jmp 0x9ba2
movq 0xe460(%rip), %rdi      # 0x17fe8
leaq 0x69f3(%rip), %rsi      # 0x10582
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3e82
jmp 0x9bbf
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x3e82
jmp 0x9bcd
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x9c25
movq (%r14), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x5fc6
movq (%r15), %rdi
callq 0x49e0
testb %al, %al
je 0x9c48
leaq -0x20(%rbp), %rdi
callq 0x3e82
jmp 0x9c77
movq 0xe3bc(%rip), %rdi      # 0x17fe8
leaq 0x697c(%rip), %rsi      # 0x105af
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x9c9a
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5fc6
movq -0x38(%rbp), %rdi
callq 0x4a24
movl %eax, %r15d
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x20(%rbp), %rdi
callq 0x3e82
testb %r15b, %r15b
je 0x9ca8
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5fc6
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xe339(%rip), %rdi      # 0x17fe8
leaq 0x6917(%rip), %rsi      # 0x105cd
jmp 0x9c33
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
jmp 0x9cd0
jmp 0x9ccd
jmp 0x9ccd
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/builtin/cons.cpp
// Function: builtin::_cdr(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::_cdr(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "cdr 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()->cdr();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4b80
cmpq $0x1, %rax
jne 0x9d29
movq (%r14), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x5fc6
movq (%r15), %rdi
callq 0x49e0
testb %al, %al
je 0x9d4c
leaq -0x20(%rbp), %rdi
callq 0x3e82
jmp 0x9d7b
movq 0xe2b8(%rip), %rdi      # 0x17fe8
leaq 0x68ba(%rip), %rsi      # 0x105f1
callq 0x31f0
movq %rax, %rdi
callq 0x3100
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x9d9e
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5fc6
movq -0x38(%rbp), %rdi
callq 0x4a24
movl %eax, %r15d
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x20(%rbp), %rdi
callq 0x3e82
testb %r15b, %r15b
je 0x9dac
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x5fc6
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5f48
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xe235(%rip), %rdi      # 0x17fe8
leaq 0x6813(%rip), %rsi      # 0x105cd
jmp 0x9d37
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
jmp 0x9dd4
jmp 0x9dd1
jmp 0x9dd1
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/builtin/arithmetic.cpp
// Function: builtin::_add(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::_add(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    sexpr_t walk = args;
    double d = 0;

    while (not walk->isnil()) {
        if (not walk->car()->isnum()) {
            cerr << "fatal: operands are not numbers!" << endl;
            return nullptr;
        }
        d += any_cast<sexpr_number>(*walk->car()->blob).n;
        walk = walk->cdr();
    }
    return num(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x58(%rbp)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x3e44
leaq -0x38(%rbp), %r14
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x38(%rbp), %r13
leaq -0x40(%rbp), %rbx
movq -0x50(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0xa151
movq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5fc6
movq -0x40(%rbp), %rdi
callq 0x4a9e
movl %eax, %r12d
movq %r14, %rdi
callq 0x3e82
testb %r12b, %r12b
je 0xa164
movq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5fc6
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x900a
movsd %xmm0, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e82
movq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5f48
movsd -0x30(%rbp), %xmm0
addsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4354
movq %r13, %rdi
callq 0x3e82
jmp 0xa0c6
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x4d67
jmp 0xa18b
movq 0xde7d(%rip), %rdi      # 0x17fe8
leaq 0x64f6(%rip), %rsi      # 0x10668
callq 0x31f0
movq -0x58(%rbp), %rbx
movq %rax, %rdi
callq 0x3100
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
leaq -0x48(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa1c4
jmp 0xa1c4
jmp 0xa1c4
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xa1bb
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e82
jmp 0xa1c7
jmp 0xa1c4
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330