LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0xb5aa
movq (%r14), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x628e
movq (%r15), %rdi
callq 0x4cec
movb $0x1, %r15b
testb %al, %al
jne 0xb56d
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x628e
movq -0x38(%rbp), %rdi
callq 0x4d54
movl %eax, %r15d
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xb56d
callq 0x4104
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb57b
callq 0x4104
testb %r15b, %r15b
je 0xb5bf
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x628e
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb607
callq 0x4104
jmp 0xb607
movq 0xea37(%rip), %r14      # 0x19fe8
leaq 0x8015(%rip), %rsi      # 0x135cd
movl $0x1d, %edx
jmp 0xb5d2
movq 0xea22(%rip), %r14      # 0x19fe8
leaq 0x801e(%rip), %rsi      # 0x135eb
movl $0x23, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb62c
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xb62f
callq 0x4104
jmp 0xb62f
jmp 0xb62c
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb63d
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fb6
cmpq $0x1, %rax
jne 0xb6ec
movq (%r14), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x628e
movq (%r15), %rdi
callq 0x4cec
movb $0x1, %r15b
testb %al, %al
jne 0xb6af
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x628e
movq -0x38(%rbp), %rdi
callq 0x4d54
movl %eax, %r15d
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xb6af
callq 0x4104
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb6bd
callq 0x4104
testb %r15b, %r15b
je 0xb701
movq (%r14), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x61be
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb749
callq 0x4104
jmp 0xb749
movq 0xe8f5(%rip), %r14      # 0x19fe8
leaq 0x7f15(%rip), %rsi      # 0x1360f
movl $0x1d, %edx
jmp 0xb714
movq 0xe8e0(%rip), %r14      # 0x19fe8
leaq 0x7edc(%rip), %rsi      # 0x135eb
movl $0x23, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb76e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xb771
callq 0x4104
jmp 0xb771
jmp 0xb76e
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xb77f
callq 0x4104
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0xbb21
movq 0xe46d(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xbb1d
incl 0x8(%rbx)
jmp 0xbb21
lock
incl 0x8(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %r12
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0xbbef
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x40(%rbp), %rdi
callq 0x4df2
movl %eax, %r13d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbb63
callq 0x4104
testb %r13b, %r13b
je 0xbbfe
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0xac3b
testq %rax, %rax
je 0xbc6c
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbba3
callq 0x4104
movq %r12, %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 0xbbd8
movq %rbx, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbbd8
callq 0x4104
movsd -0x48(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq %r13, %rbx
jmp 0xbb2e
movq %r14, %rdi
movsd -0x48(%rbp), %xmm0
callq 0x51d8
jmp 0xbc4d
movq 0xe3e3(%rip), %r15      # 0x19fe8
leaq 0x7a7c(%rip), %rsi      # 0x13688
movl $0x20, %edx
movq %r15, %rdi
callq 0x3210
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq 0xe3b1(%rip), %rdi      # 0x19fe8
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
testq %rbx, %rbx
je 0xbc5a
movq %rbx, %rdi
callq 0x4104
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4668
jmp 0xbc96
jmp 0xbc83
jmp 0xbc96
movq %rax, %rdi
callq 0x4075
jmp 0xbc96
jmp 0xbc96
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbc99
callq 0x4104
jmp 0xbc99
movq %rax, %r14
testq %rbx, %rbx
je 0xbca6
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/builtin/arithmetic.cpp
// Function: builtin::_mul(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::_mul(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    sexpr_t walk = args;
    double d = 1;

    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 $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0xbf6f
movq 0xe01f(%rip), %rax      # 0x19f80
cmpb $0x0, (%rax)
je 0xbf6b
incl 0x8(%rbx)
jmp 0xbf6f
lock
incl 0x8(%rbx)
movsd 0x7709(%rip), %xmm0     # 0x13680
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %r12
movq %r15, %rdi
callq 0x4c74
testb %al, %al
jne 0xc041
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x40(%rbp), %rdi
callq 0x4df2
movl %eax, %r13d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbfb5
callq 0x4104
testb %r13b, %r13b
je 0xc050
movq %r12, %rdi
movq %r15, %rsi
callq 0x628e
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0xac3b
testq %rax, %rax
je 0xc0be
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbff5
callq 0x4104
movq %r12, %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 0xc02a
movq %rbx, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc02a
callq 0x4104
movsd -0x48(%rbp), %xmm0
mulsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq %r13, %rbx
jmp 0xbf80
movq %r14, %rdi
movsd -0x48(%rbp), %xmm0
callq 0x51d8
jmp 0xc09f
movq 0xdf91(%rip), %r15      # 0x19fe8
leaq 0x762a(%rip), %rsi      # 0x13688
movl $0x20, %edx
movq %r15, %rdi
callq 0x3210
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq 0xdf5f(%rip), %rdi      # 0x19fe8
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
testq %rbx, %rbx
je 0xc0ac
movq %rbx, %rdi
callq 0x4104
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4668
jmp 0xc0e8
jmp 0xc0d5
jmp 0xc0e8
movq %rax, %rdi
callq 0x4075
jmp 0xc0e8
jmp 0xc0e8
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc0eb
callq 0x4104
jmp 0xc0eb
movq %rax, %r14
testq %rbx, %rbx
je 0xc0f8
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/builtin/arithmetic.cpp
// Function: valid_numeric_args(std::shared_ptr<sexpr>)
bool valid_numeric_args(sexpr_t args) {
    if (args->length() != 2) {
        cerr << "Err: expected two arguments!" << endl;
        return false;
    }
    if (not (args->car()->isnum() and args->cdr()->car()->isnum())) {
        cerr << "Err: arguments should both be numbers!" << endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4fb6
cmpq $0x2, %rax
jne 0xc3dd
movq (%rbx), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x628e
movq (%r14), %rdi
callq 0x4df2
testb %al, %al
je 0xc3f2
movq (%rbx), %rsi
leaq -0x20(%rbp), %rdi
callq 0x61be
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x628e
movq -0x30(%rbp), %rdi
callq 0x4df2
movl %eax, %ebx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xc3cd
callq 0x4104
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xc3f4
callq 0x4104
jmp 0xc3f4
movq 0xdc04(%rip), %rbx      # 0x19fe8
leaq 0x72de(%rip), %rsi      # 0x136c9
movl $0x1c, %edx
jmp 0xc41b
xorl %ebx, %ebx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc402
callq 0x4104
movb $0x1, %al
testb %bl, %bl
jne 0xc44c
movq 0xdbd9(%rip), %rbx      # 0x19fe8
leaq 0x72d0(%rip), %rsi      # 0x136e6
movl $0x26, %edx
movq %rbx, %rdi
callq 0x3210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xc46b
callq 0x4104
jmp 0xc46b
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xc480
callq 0x4104
jmp 0xc480
jmp 0xc47d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xc48e
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/eval.cpp
// Function: sexpr::resolve(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t sexpr::resolve(const sexpr_t& expr, env_t& local) {
    if (not (expr and expr->issymb()))
        return expr;
    auto sy = any_cast<sexpr_text>(*expr->blob).text();
    auto it = local.find(sy);
    if (it != end(local))
        return it->second;
    it = global.find(sy);
    if (it != end(global))
        return it->second;
    else return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xd817
movq %rdx, %r15
callq 0x4ed6
movq (%r14), %rcx
testb %al, %al
je 0xd819
movq (%rcx), %rdi
callq 0x4696
movq %rax, %r12
testq %rax, %rax
je 0xd87b
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r13
movq %r13, %rdi
callq 0x45ca
movb 0x20(%r12), %al
movb %al, 0x20(%r13)
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x389c
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xd7cc
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x31f0
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0xad96
testq %rax, %rax
jne 0xd7f2
leaq 0xc9fc(%rip), %rdi      # 0x1a1e0
leaq -0x48(%rbp), %rsi
callq 0xad96
testq %rax, %rax
je 0xd86f
movq 0x28(%rax), %rcx
movq %rcx, (%rbx)
movq 0x30(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xd844
movq 0xc773(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xd840
incl 0x8(%rax)
jmp 0xd844
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xd85d
movq 0xc750(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xd83a
incl 0x8(%rax)
jmp 0xd85d
lock
incl 0x8(%rax)
jmp 0xd85d
lock
incl 0x8(%rax)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd85d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
jmp 0xd7fd
callq 0x4668
jmp 0xd882
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd8b4
movq -0x38(%rbp), %rsi
jmp 0xd8ac
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xd8b4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x4075
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse_tokens(std::queue<token, std::deque<token, std::allocator<token>>>&, bool)
sexpr_t parse_tokens(queue<token>& q, bool quasi) {
    sexpr_t e;

    if (tok.type == token::tok_l_paren) {
        e = parse_list(q, quasi);
    } else if (is_quote(tok.type)) {
        if (not quasi and is_unquote(tok.type)) {
            cerr << "Err: unquote appeared without quasiquote" << endl;
            return nullptr;
        }
        e = parse_quote(q, quasi or tok.type == token::tok_quasi);
    } else if (tok.type == token::tok_pair) {
        cerr << "parsing error! pair is not valid" << endl;
        return nullptr;
    } else if (tok.type == token::tok_cons_flavor) {
        cerr << "Err: car/cdr must be called as operators!" << endl;
        return nullptr;
    } else {
        e = tok, q.pop();
    }
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
movl 0x7c(%rsi), %eax
testl %eax, %eax
je 0xf8b5
movl %eax, %ecx
andl $-0x4, %ecx
cmpl $0x4, %ecx
jne 0xf8cc
testb %dl, %dl
je 0xf8ef
movb $0x1, %al
jmp 0xf993
movzbl %dl, %edx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10407
jmp 0xf9a5
cmpl $0xa, %eax
je 0xf911
cmpl $0x8, %eax
jne 0xf95b
movq 0xa707(%rip), %r14      # 0x19fe8
leaq 0x3f95(%rip), %rsi      # 0x1387d
movl $0x20, %edx
jmp 0xf924
movl %eax, %ecx
notl %ecx
testb $0x6, %cl
jne 0xf98d
movq 0xa6e5(%rip), %r14      # 0x19fe8
leaq 0x4027(%rip), %rsi      # 0x13931
movl $0x28, %edx
jmp 0xf924
movq 0xa6d0(%rip), %r14      # 0x19fe8
leaq 0x3fe8(%rip), %rsi      # 0x13907
movl $0x29, %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 0xf9b3
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x1092c
movq (%r15), %r12
movq 0x8(%r15), %r13
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %r14, %rdi
callq 0x1110a
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf9ac
callq 0x4104
jmp 0xf9ac
cmpl $0x5, %eax
sete %al
movzbl %al, %edx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf644
movq (%r15), %r12
movq 0x8(%r15), %r13
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse_pair(std::queue<token, std::deque<token, std::allocator<token>>>&, std::shared_ptr<sexpr> const&, std::shared_ptr<sexpr>&)
sexpr_t parse_pair(queue<token>& q, const sexpr_t& e, sexpr_t& tail) {
    if (q.pop(); not e or tok.type == token::tok_r_paren) {
        cerr << "parsing error! pair is not valid" << endl;
        return nullptr;
    }
    sexpr_t tmp = tok;
    if (q.pop(); not tmp->isatom() or tok.type != token::tok_r_paren) {
        cerr << "parsing error! pair is not valid" << endl;
        return nullptr;
    }
    tail->setcdr(tmp);
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1110a
cmpq $0x0, (%r14)
je 0xf9fb
movq 0x10(%r12), %rsi
cmpl $0x1, 0x7c(%rsi)
jne 0xfa48
movq 0xa5e6(%rip), %r14      # 0x19fe8
leaq 0x3e74(%rip), %rsi      # 0x1387d
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 0xfafe
leaq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0x1092c
movq %r12, %rdi
callq 0x1110a
movq (%r13), %rdi
callq 0x4dbc
testb %al, %al
je 0xfaa4
movq 0x10(%r12), %rax
cmpl $0x1, 0x7c(%rax)
jne 0xfaa4
movq (%r15), %rdi
leaq -0x38(%rbp), %rsi
callq 0x615c
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xfaf0
movq 0xa4e6(%rip), %rcx      # 0x19f80
cmpb $0x0, (%rcx)
je 0xfb10
incl 0x8(%rax)
jmp 0xfaf0
movq 0xa53d(%rip), %r14      # 0x19fe8
leaq 0x3dcb(%rip), %rsi      # 0x1387d
movl $0x20, %edx
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq 0xa50b(%rip), %rdi      # 0x19fe8
callq 0x3030
movq %rax, %rdi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xfafe
callq 0x4104
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rax)
jmp 0xfaf0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xfb27
callq 0x4104
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/parser.cpp
// Function: parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
sexpr_t parse(string s) {
    queue<token> tokens;
    sexpr_t e;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0xe0(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x111c0
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x118ce
leaq -0xe0(%rbp), %r14
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movaps %xmm0, -0x40(%rbp)
movaps 0x40(%r14), %xmm0
leaq -0x90(%rbp), %r15
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movaps -0x40(%rbp), %xmm4
movaps %xmm4, (%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm2, 0x20(%r15)
movaps %xmm3, 0x30(%r15)
movaps %xmm0, 0x40(%r15)
movq %r15, %rdi
callq 0x10ee2
movq 0x48(%r14), %rax
movq %rax, %rcx
subq 0x28(%r14), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x20(%r14), %r12
movq 0x30(%r14), %rax
subq 0x38(%r14), %rax
sarq $0x7, %rax
leaq (%rax,%rcx,4), %r13
subq 0x10(%r14), %r12
sarq $0x7, %r12
movq %r15, %rdi
callq 0x11056
addq %r13, %r12
jne 0x1086b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x108e0
leaq -0x90(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
xorl %edx, %edx
callq 0xf87e
movq -0x90(%rbp), %r12
movq -0x88(%rbp), %r14
testq %r12, %r12
jne 0x108d9
movq 0x974e(%rip), %r15      # 0x19fe8
leaq 0x30d6(%rip), %rsi      # 0x13977
movl $0x1d, %edx
movq %r15, %rdi
callq 0x3210
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq 0x971c(%rip), %rdi      # 0x19fe8
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
leaq -0xe0(%rbp), %rdi
callq 0x11056
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10915
movq %rax, %rbx
testq %r14, %r14
je 0x10918
movq %r14, %rdi
callq 0x4104
jmp 0x10918
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x11056
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/include/token.hpp
// Function: token::operator std::shared_ptr<sexpr>() const
operator sexpr_t() const {
        if (type == tok_num_or_symb) {
            bool redix = false;
            bool flag = true;

            if (s == "+" || s == "-") return symb(s);
            for (auto i = 0u; i < s.length(); i++) {
                if (s[i] == '+' or s[i] == '-') {
                    if (i == 0) continue;
                    else {flag = false; break;}
                } else if (not isdigit(s[i])) {
                    flag = false;
                    break;
                } else if (s[i] == '.') {
                    if (not redix) redix = true;
                    else {flag = false; break;}
                }
            }

            if (flag) return num(stod(s));
            else return s == "nil" ? nil() : symb(s);
        } else if (type == tok_str) {
            return str(s);
        }
        return nil();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movl 0x7c(%rsi), %eax
cmpl $0x2, %eax
je 0x10a19
cmpl $0x3, %eax
jne 0x10a4a
leaq 0x58(%r12), %r14
leaq 0x2e17(%rip), %rsi      # 0x13778
movq %r14, %rdi
callq 0x30a0
testl %eax, %eax
je 0x10a3d
leaq 0x2e06(%rip), %rsi      # 0x1377e
movq %r14, %rdi
callq 0x30a0
testl %eax, %eax
je 0x10a3d
movq 0x58(%r12), %r15
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x109db
movl $0x1, %ecx
xorl %esi, %esi
xorl %edx, %edx
movzbl (%r15,%rsi), %esi
cmpl $0x2d, %esi
je 0x109af
cmpl $0x2b, %esi
jne 0x109b6
cmpl $0x1, %ecx
je 0x109d2
jmp 0x10a2a
movsbl %sil, %edi
addl $-0x30, %edi
cmpl $0x9, %edi
ja 0x10a2a
cmpb $0x2e, %sil
sete %sil
testb %dl, %sil
jne 0x10a2a
orb %sil, %dl
movl %ecx, %esi
incl %ecx
cmpq %rsi, %rax
ja 0x109a0
callq 0x3040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3180
cmpq %r15, (%r12)
je 0x10a71
movl (%r14), %eax
testl %eax, %eax
je 0x10a64
cmpl $0x22, %eax
jne 0x10a67
leaq 0x2f81(%rip), %rdi      # 0x13995
callq 0x3280
addq $0x58, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x51a3
jmp 0x10a52
leaq 0x2b49(%rip), %rsi      # 0x1357a
movq %r14, %rdi
callq 0x30a0
testl %eax, %eax
je 0x10a4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5176
jmp 0x10a52
movq %rbx, %rdi
callq 0x514c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, (%r14)
movq %rbx, %rdi
callq 0x51d8
jmp 0x10a52
leaq 0x2f1d(%rip), %rdi      # 0x13995
callq 0x3120
cmpl $0x0, (%r14)
jne 0x10a86
movl %r13d, (%r14)
movq %rax, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_paren(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_paren(string& e) {
    char c = e[0];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rax
movb (%rax), %r15b
movb %r15b, -0x19(%rbp)
movl %r15d, %r14d
andb $-0x2, %r14b
cmpb $0x28, %r14b
jne 0x1144f
movq %rdi, %rbx
movl $0x1, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3080
leaq 0x58(%rbx), %rdi
movq 0x60(%rbx), %rdx
movsbl %r15b, %r8d
movl $0x1, %ecx
xorl %esi, %esi
callq 0x3350
xorl %eax, %eax
cmpb $0x28, %r15b
setne %al
movl %eax, 0x7c(%rbx)
cmpb $0x29, %r15b
jne 0x11417
movq 0x8ebc(%rip), %rax      # 0x1a270
movq %rax, %rsi
subq 0x8e92(%rip), %rsi      # 0x1a250
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
movq 0x8e87(%rip), %rcx      # 0x1a258
movq 0x8e88(%rip), %rdx      # 0x1a260
movq %rcx, %rdi
subq %rdx, %rdi
addq 0x8e63(%rip), %rdi      # 0x1a248
shlq $0x9, %rsi
addq %rsi, %rdi
cmpq 0x8e45(%rip), %rdi      # 0x1a238
je 0x11439
cmpq %rdx, %rcx
jne 0x11403
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rax), %rcx
cmpb $0x28, -0x1(%rcx)
jne 0x11439
leaq 0x8e18(%rip), %rdi      # 0x1a228
callq 0x11de0
jmp 0x1144f
movq 0x8e3a(%rip), %rax      # 0x1a258
movq 0x8e43(%rip), %rcx      # 0x1a268
decq %rcx
cmpq %rcx, %rax
je 0x1143f
movb $0x28, (%rax)
incq 0x8e21(%rip)            # 0x1a258
jmp 0x1144f
movb $0x1, 0x78(%rbx)
jmp 0x1144f
leaq 0x8de2(%rip), %rdi      # 0x1a228
leaq -0x19(%rbp), %rsi
callq 0x11e36
cmpb $0x28, %r14b
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_string(string& e) {
    int j = 1;
    if (e[0] != '\"')
        return false;
    type = tok_str;
    for (; e[j] != '\"'; j++)
        if (e[j]) s += e[j];
        else return err = true;
    e.erase(0, j + 1);
    return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movb (%rax), %r12b
cmpb $0x22, %r12b
jne 0x114c9
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, 0x7c(%rdi)
leaq 0x58(%rdi), %r15
movl $0x2, %r13d
movzbl -0x1(%rax,%r13), %eax
testl %eax, %eax
je 0x114c4
cmpl $0x22, %eax
je 0x114b5
movsbl %al, %esi
movq %r15, %rdi
callq 0x31b0
movq (%rbx), %rax
incq %r13
jmp 0x11493
movl %r13d, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3080
jmp 0x114c9
movb $0x1, 0x78(%r14)
cmpb $0x22, %r12b
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_special(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_special(string& e) {
    char c = e[0];

    if (c == '\'') {
        s = c, type = tok_quote;
        e.erase(0, 1);
        return true;
    } else if (c == '.') {
        s = c, type = tok_pair;
        e.erase(0, 1);
        return true;
    } else if (c == '`') {
        s = c, type = tok_quasi;
        e.erase(0, 1);
        return true;
    } else if (c == ',') {
        s = c, type = (e[1] == '@' ? tok_unquote_sp : tok_unquote);
        e.erase(0, 1 + (e[1] == '@'));
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
jg 0x1154f
cmpl $0x27, %ecx
je 0x11587
cmpl $0x2c, %ecx
jne 0x115e8
leaq 0x58(%r14), %rdi
movq 0x60(%r14), %rdx
movl $0x1, %ecx
xorl %esi, %esi
movl $0x2c, %r8d
callq 0x3350
movq (%rbx), %rax
xorl %ecx, %ecx
cmpb $0x40, 0x1(%rax)
sete %cl
orl $0x6, %ecx
movl %ecx, 0x7c(%r14)
xorl %r15d, %r15d
cmpb $0x40, 0x1(%rax)
sete %r15b
incq %r15
jmp 0x115d9
cmpl $0x2e, %ecx
je 0x115b1
cmpl $0x60, %ecx
jne 0x115e8
leaq 0x58(%r14), %rdi
movq 0x60(%r14), %rdx
movl $0x1, %r15d
movl $0x1, %ecx
xorl %esi, %esi
movl $0x60, %r8d
callq 0x3350
movl $0x5, 0x7c(%r14)
jmp 0x115d9
leaq 0x58(%r14), %rdi
movq 0x60(%r14), %rdx
movl $0x1, %r15d
movl $0x1, %ecx
xorl %esi, %esi
movl $0x27, %r8d
callq 0x3350
movl $0x4, 0x7c(%r14)
jmp 0x115d9
leaq 0x58(%r14), %rdi
movq 0x60(%r14), %rdx
movl $0x1, %r15d
movl $0x1, %ecx
xorl %esi, %esi
movl $0x2e, %r8d
callq 0x3350
movl $0x8, 0x7c(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3080
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, token&)
bool token::next_token(string& e, token& tok) {
    for (int i = 0; e[i] and isspace(e[i]); i++)
        e.erase(i--, 1);
    if (e.empty() or e[0] == ';')
        return false;
    return tok.next_paren(e) or tok.next_string(e)
        or tok.next_special(e) or tok.next_symbol(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movb (%rax), %r12b
testb %r12b, %r12b
je 0x1186b
movsbl %r12b, %edi
callq 0x3050
testl %eax, %eax
je 0x11877
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3080
movq (%rbx), %rax
jmp 0x11842
cmpq $0x0, 0x8(%rbx)
jne 0x11887
xorl %r15d, %r15d
jmp 0x118c2
xorl %r15d, %r15d
cmpb $0x3b, %r12b
je 0x118c2
cmpq $0x0, 0x8(%rbx)
je 0x118c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1134c
movb $0x1, %r15b
testb %al, %al
jne 0x118c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11462
testb %al, %al
jne 0x118c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x114e0
testb %al, %al
jne 0x118c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x115f4
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/random_median.cpp
// Function: AddNumber(int)
void AddNumber(int num) {
    // always store extra in high heap
    if(high.size() == 0) {
        high.push(num);
        return;
    }

    if(low.size() != high.size()) {
        if(num < high.top()) {
            low.push(num);
        } else {
            low.push(high.top());
            high.pop();
            high.push(num);
        }
    } else {
        if(num < low.top()) {
            high.push(low.top());
            low.pop();
            low.push(num);
        } else {
            high.push(num);
        }
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, 0xc(%rsp)
movq 0x2db0(%rip), %rcx      # 0x40d8
movq 0x2da1(%rip), %rsi      # 0x40d0
subq %rsi, %rcx
je 0x1376
movq 0x2d7d(%rip), %rdx      # 0x40b8
movq 0x2d6e(%rip), %rax      # 0x40b0
subq %rax, %rdx
cmpq %rcx, %rdx
jne 0x1384
cmpl %edi, (%rax)
jle 0x1376
leaq 0x2d7b(%rip), %rdi      # 0x40d0
movq %rax, %rsi
callq 0x14cc
leaq 0x2d4c(%rip), %rbx      # 0x40b0
movq %rbx, %rdi
callq 0x15e0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
jmp 0x1394
leaq 0x2d53(%rip), %rdi      # 0x40d0
leaq 0xc(%rsp), %rsi
jmp 0x13be
cmpl %edi, (%rsi)
jle 0x139b
leaq 0x2d21(%rip), %rdi      # 0x40b0
leaq 0xc(%rsp), %rsi
callq 0x1536
jmp 0x13c3
leaq 0x2d0e(%rip), %rdi      # 0x40b0
callq 0x1536
leaq 0x2d22(%rip), %rbx      # 0x40d0
movq %rbx, %rdi
callq 0x15a0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x14cc
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/random_median.cpp
// Function: main
int main()
{
    for(int i = 0; i < 10; i++) {
        int num = rand() % 30;
        AddNumber(num);
        cout << "Add: " << num << "  Median: " << GetMedian() << endl;
        //if(i > 1)
        //cout << "LOW: " << low.top() << "   HIGH: " << high.top() << endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xa, %ebp
movq 0x2bfb(%rip), %rbx      # 0x3fd8
leaq 0xc3c(%rip), %r14       # 0x2020
leaq 0xc3b(%rip), %r15       # 0x2026
callq 0x1040
cltq
imulq $-0x77777777, %rax, %r12 # imm = 0x88888889
shrq $0x20, %r12
addl %eax, %r12d
movl %r12d, %ecx
shrl $0x1f, %ecx
sarl $0x4, %r12d
addl %ecx, %r12d
movl %r12d, %ecx
shll $0x5, %ecx
addl %r12d, %r12d
subl %ecx, %r12d
addl %eax, %r12d
movl %r12d, %edi
callq 0x1318
movl $0x5, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1110
movq %rax, %r12
movl $0xa, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
callq 0x12bc
movq %r12, %rdi
callq 0x10f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
decl %ebp
jne 0x13eb
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]tsvtools/./join.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> join<char const [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char const (&) [2])
std::string join(std::vector<T>& elems, S& delim) {
    std::stringstream ss;
    typename std::vector<T>::iterator e = elems.begin();
    ss << *e++;
    for (; e != elems.end(); ++e) {
        ss << delim << *e;
    }
    return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2100
movq (%r15), %r13
leaq 0x18(%rsp), %r12
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x21d0
addq $0x20, %r13
cmpq 0x8(%r15), %r13
je 0x2b94
movq %r14, %rdi
callq 0x20b0
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21d0
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq $0x20, %r13
movq %r12, %rdi
callq 0x21d0
jmp 0x2b62
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2220
movq 0x3408(%rip), %rsi      # 0x5fb0
leaq 0x8(%rsp), %rdi
callq 0x2120
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2bd7
jmp 0x2bd7
movq %rax, %rbx
movq 0x33cf(%rip), %rsi      # 0x5fb0
leaq 0x8(%rsp), %rdi
callq 0x2120
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]tsvtools/split.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while(std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x2230
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2280
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3772
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ae6
jmp 0x374a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3789
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x2820(%rip), %rsi      # 0x5fb0
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0xa8(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x27d5(%rip), %rsi      # 0x5fb0
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0xa8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]tsvtools/split.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string> &split(const std::string &s, const std::string& delims, std::vector<std::string> &elems) {
    char* tok;
    char cchars [s.size()+1];
    char* cstr = &cchars[0];
    strcpy(cstr, s.c_str());
    tok = strtok(cstr, delims.c_str());
    while (tok != NULL) {
        elems.push_back(tok);
        tok = strtok(NULL, delims.c_str());
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %rax
movq %rsp, %r15
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq (%rdi), %rsi
movq %r15, %rdi
callq 0x2160
movq (%r14), %rsi
movq %r15, %rdi
callq 0x2210
testq %rax, %rax
je 0x38ee
movq %rax, %r12
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %r15
movq %r13, -0x48(%rbp)
movq %r12, %rdi
callq 0x20b0
leaq (%rax,%r12), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ce2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d78
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x38dc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq (%r14), %rsi
xorl %edi, %edi
callq 0x2210
movq %rax, %r12
testq %rax, %rax
jne 0x38a1
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x3918
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Options.cpp
// Function: PrintOpts(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void PrintOpts(const std::string &exec, const double DMAX) {

	printf("\nUsage:   ./%s [-option] [argument]\n\n", exec.c_str());
	printf("Options:  -r receptor.pdb \\  # PDB file with receptor's coordinates\n");
	printf("          -l ligand.pdb \\    # (optional) PDB file with ligand's coordinates\n");
	printf("          -t table.txt \\     # (optional) %s contact potential table \n", exec.c_str());
	printf("          -d dmax            # (optional) contact distance, default dmax=%.1fA\n", DMAX);
	printf("\n");

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xaea4(%rip), %rdi      # 0x19028
xorl %eax, %eax
callq 0x2050
leaq 0xaf89(%rip), %rdi      # 0x1911b
callq 0x2310
leaq 0xafc1(%rip), %rdi      # 0x1915f
callq 0x2310
movq (%rbx), %rsi
leaq 0xaea1(%rip), %rdi      # 0x1904e
xorl %eax, %eax
callq 0x2050
leaq 0xaeda(%rip), %rdi      # 0x19095
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
movl $0xa, %edi
addq $0x10, %rsp
popq %rbx
jmp 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Options.cpp
// Function: GetOpts(int, char**, OPTS&)
bool GetOpts(int argc, char *argv[], OPTS &opts) {

	char tmp;
	while ((tmp = getopt(argc, argv, "hs:r:l:t:d:")) != -1) {
		switch (tmp) {
		case 'h': /* help */
			printf("!!! HELP !!!\n");
			return false;
			break;
		case 'r': /* receptor file */
			opts.rec = std::string(optarg);
			break;
		case 'l': /* ligand file */
			opts.lig = std::string(optarg);
			break;
		case 't': /* table file */
			opts.table = std::string(optarg);
			break;
		case 'd': /* distance cutoff */
			opts.dmax = atof(optarg);
			break;
		default:
			return false;
			break;
		}
	}

	if (opts.rec == "") {
		printf("Error: receptor file not specified ('-r')\n");
		return false;
	}

	return true;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0xaef1(%rip), %rdx      # 0x190e5
callq 0x2090
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0xe2f1
leaq 0x40(%rbx), %rcx
movq %rcx, 0x30(%rsp)
leaq 0x20(%rbx), %rcx
movq %rcx, 0x28(%rsp)
leaq 0xade4(%rip), %r12      # 0x19004
leaq 0xaebe(%rip), %r13      # 0x190e5
leaq 0x8(%rsp), %r15
sarl $0x18, %eax
addl $-0x64, %eax
rorl %eax
cmpl $0x8, %eax
ja 0xe31d
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x1ed83(%rip), %rax     # 0x2cfd0
movq (%rax), %rdi
callq 0x22a0
movsd %xmm0, 0x60(%rbx)
jmp 0xe2d6
movq 0x1ed6d(%rip), %rax     # 0x2cfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xe32e
movq %rbx, %rdi
jmp 0xe2b2
movq 0x1ed51(%rip), %rax     # 0x2cfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xe32e
movq 0x28(%rsp), %rdi
jmp 0xe2b2
movq 0x1ed33(%rip), %rax     # 0x2cfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xe32e
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x2290
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe2d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2220
movl %ebp, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2090
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0xe22c
leaq 0xad55(%rip), %rsi      # 0x1904d
movq %rbx, %rdi
callq 0x20b0
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0xe31f
leaq 0xae9d(%rip), %rdi      # 0x191ac
jmp 0xe318
leaq 0xaebe(%rip), %rdi      # 0x191d6
callq 0x2310
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::Atom()
Atom::Atom() :
		atomNum(1), altLoc(' '), x(0.0), y(0.0), z(0.0), occup(0.0), temp(0.0), residue(
		NULL), q(0.0), r(0.0), type(' ') {

	name[0] = '\n';
	x = y = z = 0.0;
	element[0] = '\n';
	charge[0] = '\n';

}

// Assembly:
movl $0x1, (%rdi)
movb $0x20, %al
movb %al, 0x9(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x40(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x50(%rdi)
movb %al, 0x58(%rdi)
movb $0xa, %al
movb %al, 0x4(%rdi)
movups %xmm0, 0x10(%rdi)
movq %rcx, 0x20(%rdi)
movb %al, 0x38(%rdi)
movb %al, 0x3b(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::Dist(Atom const&, Atom const&)
double Atom::Dist(const Atom &A, const Atom &B) {

	double x = A.x - B.x;
	double y = A.y - B.y;
	double z = A.z - B.z;

	return sqrt(x * x + y * y + z * z);

}

// Assembly:
movsd 0x10(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
subsd 0x10(%rsi), %xmm0
subsd 0x18(%rsi), %xmm1
movsd 0x20(%rdi), %xmm2
subsd 0x20(%rsi), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::ReadAtomRecordPQR(char*)
AtomRecord Chain::ReadAtomRecordPQR(char* str) {

	AtomRecord A;

	/*
	 * reading PDB ATOM string in the reverse direction
	 */

	/* fields missing from PQR files */
	A.segId[0] = '\0';
	A.element[0] = '\0';
	A.charge[0] = '\0';

	/* save atom charge and radius in Temperature factor
	 * and Occupancy respectively */
	str[80] = '\0';
	sscanf(str + 54, "%lf %lf", &(A.q), &(A.r));
	A.temp = A.q;
	A.occup = A.r;

	/* Z coordinate */
	str[54] = '\0';
	A.z = atof(str + 46);

	/* Y coordinate */
	str[46] = '\0';
	A.y = atof(str + 38);

	/* X coordinate */
	str[38] = '\0';
	A.x = atof(str + 30);

	/* Code for insertion of residues */
	A.insCode = str[26];

	/* Residue sequence number */
	str[26] = '\0';
	A.resNum = atoi(str + 22);

	/* Chain identifier */
	A.chainId = str[21];

	/* Residue name */
	str[20] = '\0';
	//strncpy(A.resName, str + 17, 4);
	sscanf(str + 17, "%s", A.resName); /* no spaces in residue name */

	/* Alternate location indicator */
	A.altLoc = str[16];

	/* Atom name */
	str[16] = '\0';
	//strncpy(A.atomName, str + 12, 5);
	sscanf(str + 12, "%s", A.atomName);

	/* Atom serial number */
	str[11] = '\0';
	A.atomNum = atoi(str + 6);

	A.charge[0] = A.element[0] = '\0';

	return A;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, 0x40(%rdi)
movb %bpl, 0x45(%rdi)
movb %bpl, 0x48(%rdi)
movb %bpl, 0x50(%rdx)
leaq 0x36(%rdx), %rdi
leaq 0x50(%rbx), %rdx
leaq 0x58(%rbx), %rcx
leaq 0xc343(%rip), %rsi      # 0x1abcd
xorl %eax, %eax
callq 0x21f0
movups 0x50(%rbx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x30(%rbx)
movb %bpl, 0x36(%r14)
leaq 0x2e(%r14), %rdi
callq 0x22a0
movsd %xmm0, 0x28(%rbx)
movb %bpl, 0x2e(%r14)
leaq 0x26(%r14), %rdi
callq 0x22a0
movsd %xmm0, 0x20(%rbx)
movb %bpl, 0x26(%r14)
leaq 0x1e(%r14), %rdi
callq 0x22a0
movsd %xmm0, 0x18(%rbx)
movb 0x1a(%r14), %al
movb %al, 0x14(%rbx)
movb %bpl, 0x1a(%r14)
leaq 0x16(%r14), %rdi
callq 0x2330
movl %eax, 0x10(%rbx)
movb 0x15(%r14), %al
movb %al, 0xe(%rbx)
movb %bpl, 0x14(%r14)
leaq 0x11(%r14), %rdi
leaq 0xa(%rbx), %rdx
leaq 0xe5c3(%rip), %r15      # 0x1cec7
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movb 0x10(%r14), %al
movb %al, 0x9(%rbx)
movb %bpl, 0x10(%r14)
leaq 0xc(%r14), %rdi
leaq 0x4(%rbx), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movb %bpl, 0xb(%r14)
addq $0x6, %r14
movq %r14, %rdi
callq 0x2330
movl %eax, (%rbx)
movb %bpl, 0x45(%rbx)
movb %bpl, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop