LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::exp(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::exp(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::exp(std::min(b, (T)EXP_MAX));};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2ee62
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x7423(%rip), %rax      # 0x362a6
movq %rax, 0x18(%r8)
leaq 0x743a(%rip), %rax      # 0x362c8
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eeb1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2eedf
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eed7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sqrt(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sqrt(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::sqrt(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2ef26
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x7399(%rip), %rax      # 0x362e0
movq %rax, 0x18(%r8)
leaq 0x73b4(%rip), %rax      # 0x36306
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ef75
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2efa3
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ef9b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sin(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sin(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::sin(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2efea
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x7313(%rip), %rax      # 0x3631e
movq %rax, 0x18(%r8)
leaq 0x731e(%rip), %rax      # 0x36334
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f039
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f067
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f05f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::cos(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::cos(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::cos(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2f0ae
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x727d(%rip), %rax      # 0x3634c
movq %rax, 0x18(%r8)
leaq 0x7288(%rip), %rax      # 0x36362
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f0fd
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f12b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f123
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sigmoid(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sigmoid(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = 1 / (1 + std::exp(-(std::min((T)SIGMOID_MAX, std::max(b, (T)SIGMOID_MIN)))));};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2f172
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x71e7(%rip), %rax      # 0x3637a
movq %rax, 0x18(%r8)
leaq 0x721c(%rip), %rax      # 0x363ba
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f1c1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f1ef
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f1e7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sigmoid_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sigmoid_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = b * (1 - b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2f236
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x717b(%rip), %rax      # 0x363d2
movq %rax, 0x18(%r8)
leaq 0x7182(%rip), %rax      # 0x363e4
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f285
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f2b3
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f2ab
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::softmax(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::softmax(Matrix<T>& mat, const Matrix<T>& mat_a){
    T max = mat_a.max();
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }

    auto lambda = [](T* a, const T& max){*a = std::exp(std::max((*a - max), (T)SOFTMAX_MIN));};
    _po.parallel_mul2one(mat.data(), mat.get_size(), max, lambda);
    mat /=  mat.sum();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x29880
movl %eax, 0xc(%rsp)
cmpq %r12, %rbx
je 0x2f351
movq 0x10(%r12), %r15
movq (%r12), %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
movq 0x8(%r12), %rbp
movq %rbp, %r12
imulq %r13, %r12
cmpq %r12, %rax
je 0x2f337
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2f314
callq 0x9420
movq %r12, %rax
shrq $0x3e, %rax
leaq (,%r12,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%rbx)
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x2, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x92b0
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x708c(%rip), %rax      # 0x363fc
movq %rax, 0x18(%r8)
leaq 0x70a5(%rip), %rax      # 0x36420
movq %rax, 0x10(%r8)
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
callq 0xa5c8
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f3a5
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x29ee6
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x20c6a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f3f1
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f3e9
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::tanh(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::tanh(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = 2.0 /(1.0 + std::exp(std::min((T)EXP_MAX, -2 * b))) - 1.0;};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2f438
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6fdf(%rip), %rax      # 0x36438
movq %rax, 0x18(%r8)
leaq 0x7016(%rip), %rax      # 0x3647a
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f487
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f4b5
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f4ad
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::tanh_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::tanh_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ T tanh = std::exp(std::min((T)EXP_MAX, -2 * b)); *a = 1 - tanh * tanh;};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2f4fc
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6f75(%rip), %rax      # 0x36492
movq %rax, 0x18(%r8)
leaq 0x6f9a(%rip), %rax      # 0x364c2
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f54b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f579
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f571
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::relu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::relu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b < 0) {*a = 0;} };
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2f60f
movq 0x10(%r14), %rsi
movq (%r14), %rbp
movq 0x8(%r15), %rax
imulq (%r15), %rax
movq 0x8(%r14), %r12
movq %r12, %r13
imulq %rbp, %r13
cmpq %r13, %rax
je 0x2f5f8
movq %rsi, 0x8(%rsp)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x2f5d0
callq 0x9420
movq %r13, %rax
shrq $0x3e, %rax
leaq (,%r13,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%r15)
movq 0x8(%rsp), %rsi
movq %rbp, (%r15)
movq %r12, 0x8(%r15)
movq 0x10(%r15), %rdi
shlq $0x2, %r13
movq %r13, %rdx
callq 0x92b0
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x6ea8(%rip), %rax      # 0x364da
movq %rax, 0x18(%r8)
leaq 0x6ead(%rip), %rax      # 0x364ea
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f662
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f697
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f68f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::relu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::relu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b > 0) {*a = 1;} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2f6cf
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6e12(%rip), %rax      # 0x36502
movq %rax, 0x18(%r8)
leaq 0x6e17(%rip), %rax      # 0x36512
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f71e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f74c
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f744
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::leaky_relu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::leaky_relu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b < 0) {*a = (T)(0.01 * b);} };
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2f7e1
movq 0x10(%r14), %rsi
movq (%r14), %rbp
movq 0x8(%r15), %rax
imulq (%r15), %rax
movq 0x8(%r14), %r12
movq %r12, %r13
imulq %rbp, %r13
cmpq %r13, %rax
je 0x2f7ca
movq %rsi, 0x8(%rsp)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x2f7a2
callq 0x9420
movq %r13, %rax
shrq $0x3e, %rax
leaq (,%r13,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%r15)
movq 0x8(%rsp), %rsi
movq %rbp, (%r15)
movq %r12, 0x8(%r15)
movq 0x10(%r15), %rdi
shlq $0x2, %r13
movq %r13, %rdx
callq 0x92b0
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x6d26(%rip), %rax      # 0x3652a
movq %rax, 0x18(%r8)
leaq 0x6d39(%rip), %rax      # 0x36548
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f834
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f869
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2f861
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::leaky_relu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::leaky_relu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0){*a = (T)1;} else{*a = (T)0.01;} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2f8a1
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6c9e(%rip), %rax      # 0x36560
movq %rax, 0x18(%r8)
leaq 0x6ca1(%rip), %rax      # 0x3656e
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f8f0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f91e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f916
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::elu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::elu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0) {*a = b;} else{*a = std::exp(std::min((T)EXP_MAX, b)) - 1;} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2f955
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6c10(%rip), %rax      # 0x36586
movq %rax, 0x18(%r8)
leaq 0x6c29(%rip), %rax      # 0x365aa
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f9a4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f9d2
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f9ca
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::elu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::elu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0) {*a = 1;} else{*a = std::exp(std::min((T)EXP_MAX, b));} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2fa09
movq %rsp, %rsi
movl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x19626
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6b98(%rip), %rax      # 0x365c2
movq %rax, 0x18(%r8)
leaq 0x6bad(%rip), %rax      # 0x365e2
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2fa58
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2fa86
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2fa7e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::LogMessage::generate_log_message()
void LogMessage::generate_log_message(){
    time_t timep;
    time(&timep);
    char time_data[64];
    strftime(time_data, sizeof(time_data), "%Y-%m-%d %H:%M:%S", localtime(&timep));
    if(!g_log_inited){
        fprintf(stderr, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data,  _name, _line, str().c_str());
    }else{
        for(auto& fd : g_log_fds[this->_severity]){
            dprintf(fd, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data, _name, _line, str().c_str());
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x9330
movq %r14, %rdi
callq 0x9260
leaq 0x702e(%rip), %rdx      # 0x3faa6
leaq 0x40(%rsp), %rdi
movl $0x40, %esi
movq %rax, %rcx
callq 0x92a0
cmpb $0x0, 0x1f96f(%rip)     # 0x58400
je 0x38b47
movslq 0x7c(%rbx), %rax
movq 0x1f92e(%rip), %rcx     # 0x583d0
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r14
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r14
je 0x38b35
leaq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
movl (%r14), %ebp
movslq 0x7c(%rbx), %rax
movq 0x1f8e0(%rip), %rcx     # 0x583b0
shlq $0x5, %rax
movq (%rcx,%rax), %r15
movq 0x70(%rbx), %r12
movl 0x78(%rbx), %r13d
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9530
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl %ebp, %edi
leaq 0x6fb7(%rip), %rsi      # 0x3fab8
movq %r15, %rdx
leaq 0x40(%rsp), %rcx
movq %r12, %r8
movl %r13d, %r9d
xorl %eax, %eax
callq 0x91e0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x38b2a
callq 0x9350
addq $0x4, %r14
cmpq 0x10(%rsp), %r14
jne 0x38ac2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x97bd
jmp 0x38b35
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x38b6d
callq 0x9350
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/khashl/test.c
// Function: test_int
KHASHL_MAP_INIT(, intmap_t, intmap, uint32_t, int, hash_fn, kh_eq_generic)

uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	intmap_t *h;
	h = intmap_init();
	for (i = 0, x = x0; i < n; ++i) {
		khint_t k;
		int absent;
		x = hash32(x);
		k = intmap_put(h, get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
		if (absent) kh_val(h, k) = 0;
		z += ++kh_val(h, k);
#else
		if (absent) ++z;
		else intmap_del(h, k);
#endif
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u; capacity: %u\n", kh_size(h), z, kh_capacity(h));
	x = kh_size(h);
	intmap_destroy(h);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movl %edi, %r15d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x1060
movq %rax, %rbx
movl $0x0, %r14d
testl %r15d, %r15d
je 0x14b2
movl %r15d, %ebp
shrl $0x2, %ebp
xorl %r14d, %r14d
leaq 0x4(%rsp), %r13
movl %r12d, %eax
shll $0xf, %eax
notl %eax
addl %r12d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r12d
shrl $0x10, %r12d
xorl %eax, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %esi
shrl $0x10, %esi
xorl %eax, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x178f
cmpl $0x0, 0x4(%rsp)
movl %eax, %eax
je 0x1494
movq 0x10(%rbx), %rcx
andl $0x0, 0x4(%rcx,%rax,8)
movq 0x10(%rbx), %rcx
movl 0x4(%rcx,%rax,8), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rcx,%rax,8)
addl %edx, %r14d
incl %r14d
decl %r15d
jne 0x1417
movq 0x2b3f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl 0x4(%rbx), %edx
cmpq $0x0, 0x10(%rbx)
movl $0x0, %r8d
je 0x14d5
movb (%rbx), %cl
pushq $0x1
popq %r8
shll %cl, %r8d
leaq 0xb99(%rip), %rsi       # 0x2075
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movl 0x4(%rbx), %ebp
movq %rbx, %rdi
callq 0x1682
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::load(unsigned int)
uint32_t MIPS::BUS::load(uint32_t addr) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF0004) {
    if (inputBuffer.empty()) {
      std::string input;
      getline(std::cin, input);
      input += "\n";
      for (int i = 0; i < input.length(); i++)
        inputBuffer.push_back(input[i]);
    }
    char in = inputBuffer.front();
    inputBuffer.pop_front();
    return in;
  } else {
    return ram.load(addr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xffff0004, %esi       # imm = 0xFFFF0004
jne 0x370d
leaq 0x8(%rbx), %r14
movq 0x38(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x36f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x9974(%rip), %rdi      # 0xcfd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %edx
movq 0x9959(%rip), %rdi      # 0xcfd8
leaq 0x8(%rsp), %rsi
callq 0x33c0
leaq 0x5974(%rip), %rsi      # 0x9004
leaq 0x8(%rsp), %rdi
callq 0x33d0
cmpq $0x0, 0x10(%rsp)
je 0x36d9
xorl %r12d, %r12d
movq 0x8(%rsp), %rsi
addq %r12, %rsi
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
je 0x36c7
movb (%rsi), %cl
movb %cl, (%rax)
incq 0x38(%rbx)
jmp 0x36cf
movq %r14, %rdi
callq 0x3b62
incq %r12
cmpq %r12, 0x10(%rsp)
ja 0x36a5
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x18(%rbx), %rax
movsbl (%rax), %ebx
movq %r14, %rdi
callq 0x3824
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rbx), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x83c6
jmp 0x3722
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x373c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::store(unsigned int, unsigned int)
void MIPS::BUS::store(uint32_t addr, uint32_t data) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF000C) {
    outputBuffer = std::string(1, (char)data);
  } else {
    ram.store(addr, data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0xffff000c, %esi       # imm = 0xFFFF000C
jne 0x37a2
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movsbl %dl, %edx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x3270
addq $0x58, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3798
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x81be
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::CPU(MIPS::BUS&)
MIPS::CPU::CPU(MIPS::BUS & bus) : MEM(bus)
{
  // Internal flags and tracking vars
  isExecuting = true;
  cycles = 0;
  stage = S_FETCH;

  // Setup registers
  PC = 0x00000000;
  hi = lo = 0;
  RA = RB = RZ = RM = RY = 0;
  for (int i = 0; i < 32; i++) R[i] = 0;

  R[31] = 0x8123456C; // Exit address
  R[30] = 0x01000000; // Start of Stack
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x98(%rdi)
movb $0x1, (%rdi)
addq $0x4, %rdi
xorl %r14d, %r14d
movq %r14, 0x8c(%rbx)
movl $0x0, 0x94(%rbx)
movl $0x84, %edx
xorl %esi, %esi
callq 0x3130
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
movq %r14, 0xb0(%rbx)
movabsq $-0x7edcba93ff000000, %rax # imm = 0x8123456C01000000
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::setiRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void MIPS::CPU::setiRegister(std::string reg, uint32_t val) {
  #define IREG(name_str, var) if (reg == name_str) var = val;
    IREG("RA", RA);
    IREG("RB", RB);
    IREG("RZ", RZ);
    IREG("RM", RM);
    IREG("RY", RY);
    IREG("IR", IR);
    IREG("PC", PC);
    IREG("hi", hi);
    IREG("lo", lo);
  #undef IREG
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x52f2(%rip), %rsi      # 0x90e0
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e01
movl %ebx, 0xa4(%r14)
leaq 0x52db(%rip), %rsi      # 0x90e3
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e1b
movl %ebx, 0xa8(%r14)
leaq 0x52c4(%rip), %rsi      # 0x90e6
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e35
movl %ebx, 0xac(%r14)
leaq 0x52ad(%rip), %rsi      # 0x90e9
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e4f
movl %ebx, 0xb0(%r14)
leaq 0x5296(%rip), %rsi      # 0x90ec
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e69
movl %ebx, 0xb4(%r14)
leaq 0x527f(%rip), %rsi      # 0x90ef
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e83
movl %ebx, 0x88(%r14)
leaq 0x5268(%rip), %rsi      # 0x90f2
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3e9d
movl %ebx, 0x8c(%r14)
leaq 0x5251(%rip), %rsi      # 0x90f5
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3eb7
movl %ebx, 0x90(%r14)
leaq 0x523a(%rip), %rsi      # 0x90f8
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
jne 0x3ed1
movl %ebx, 0x94(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::getiRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint32_t MIPS::CPU::getiRegister(std::string reg) {
  #define IREG(name_str, var) if (reg == name_str) return var;
    IREG("RA", RA);
    IREG("RB", RB);
    IREG("RZ", RZ);
    IREG("RM", RM);
    IREG("RY", RY);
    IREG("IR", IR);
    IREG("PC", PC);
    IREG("hi", hi);
    IREG("lo", lo);
  #undef IREG

  return 0xBADA5555;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x51db(%rip), %rsi      # 0x90e0
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3fc8
leaq 0x51c7(%rip), %rsi      # 0x90e3
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3fd0
leaq 0x51b3(%rip), %rsi      # 0x90e6
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3fd8
leaq 0x519f(%rip), %rsi      # 0x90e9
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3fe0
leaq 0x518b(%rip), %rsi      # 0x90ec
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3fe8
leaq 0x517b(%rip), %rsi      # 0x90ef
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3ff0
leaq 0x516b(%rip), %rsi      # 0x90f2
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x3ff8
leaq 0x515b(%rip), %rsi      # 0x90f5
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x4000
leaq 0x514b(%rip), %rsi      # 0x90f8
movq %r14, %rdi
callq 0x3090
movl %eax, %ecx
movl $0xbada5555, %eax       # imm = 0xBADA5555
testl %ecx, %ecx
jne 0x4006
movl 0x94(%rbx), %eax
jmp 0x4006
movl 0xa4(%rbx), %eax
jmp 0x4006
movl 0xa8(%rbx), %eax
jmp 0x4006
movl 0xac(%rbx), %eax
jmp 0x4006
movl 0xb0(%rbx), %eax
jmp 0x4006
movl 0xb4(%rbx), %eax
jmp 0x4006
movl 0x88(%rbx), %eax
jmp 0x4006
movl 0x8c(%rbx), %eax
jmp 0x4006
movl 0x90(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::do_cycle()
void MIPS::CPU::do_cycle() {
  switch (stage) {
    case S_FETCH : fetch (); break;
    case S_DECODE: decode(); break;
    case S_EXEC  : exec  (); break;
    case S_MEMORY: memory(); break;
    case S_WBACK : wback (); break;
  }
  cycles++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xa0(%rdi), %eax
cmpq $0x4, %rax
ja 0x409e
leaq 0x5025(%rip), %rcx      # 0x9060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x40a4
jmp 0x409e
movq %rbx, %rdi
callq 0x43a6
jmp 0x409e
movq %rbx, %rdi
callq 0x4114
jmp 0x409e
movq %rbx, %rdi
callq 0x432e
jmp 0x409e
movl 0x88(%rbx), %eax
movl %eax, %ecx
shrl $0x13, %ecx
andl $0x7c, %ecx
movl 0x8(%rbx,%rcx), %ecx
movl %ecx, 0xa4(%rbx)
shrl $0xe, %eax
andl $0x7c, %eax
movl 0x8(%rbx,%rax), %eax
movl %eax, 0xa8(%rbx)
movl $0x2, 0xa0(%rbx)
incl 0x4(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::decode()
void MIPS::CPU::decode() {
  uint8_t  $s, $t;

  $s = (IR >> 21) & 0x1F;
  $t = (IR >> 16) & 0x1F;

  RA = R[$s];
  RB = R[$t];

  stage = S_EXEC;
}

// Assembly:
movl 0x88(%rdi), %eax
movl %eax, %ecx
shrl $0x13, %ecx
andl $0x7c, %ecx
movl 0x8(%rdi,%rcx), %ecx
movl %ecx, 0xa4(%rdi)
shrl $0xe, %eax
andl $0x7c, %eax
movl 0x8(%rdi,%rax), %eax
movl %eax, 0xa8(%rdi)
movl $0x2, 0xa0(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::memory()
void MIPS::CPU::memory() {
  switch (decodeOPcode(IR)) {
    case OP_LIS:
    case OP_LW:
      RY = MEM.load(RZ);
      break;
    case OP_SW:
      MEM.store(RZ, RM);
      break;
    default:
      RY = RZ;
      break;
  }

  stage = S_WBACK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x88(%rdi), %ecx
cmpl $0x4000000, %ecx        # imm = 0x4000000
movl $0x3f, %edx
movl $0xfc000000, %eax       # imm = 0xFC000000
cmovbl %edx, %eax
andl %ecx, %eax
cmpl $0x14, %eax
je 0x4360
cmpl $0xac000000, %eax       # imm = 0xAC000000
je 0x4374
cmpl $0x8c000000, %eax       # imm = 0x8C000000
jne 0x438e
movq 0x98(%rbx), %rdi
movl 0xac(%rbx), %esi
callq 0x361c
jmp 0x4394
movq 0x98(%rbx), %rdi
movl 0xac(%rbx), %esi
movl 0xb0(%rbx), %edx
callq 0x3744
jmp 0x439a
movl 0xac(%rbx), %eax
movl %eax, 0xb4(%rbx)
movl $0x4, 0xa0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::Debugger(MIPS::CPU&, MIPS::RAM&, MIPS::BUS&)
Debugger::Debugger(CPU & cpu, RAM & ram, BUS & bus)
: cpu(cpu), ram(ram), bus(bus)
{
  prevInput = "step";

  cycleStep = false;

  step = false;

  // Break at the start of the program
  breakpoints.insert(0x00000000);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
leaq 0x20(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x50(%rdi), %r14
leaq 0x58(%rdi), %rax
movl %ecx, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
leaq 0x88(%rdi), %rax
movl %ecx, 0x88(%rdi)
movq %rcx, 0x90(%rdi)
movq %rax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq %rcx, 0xa8(%rdi)
leaq 0xb0(%rdi), %r15
leaq 0xc0(%rdi), %r13
movq %r13, 0xb0(%rdi)
movq %rcx, 0xb8(%rdi)
movb $0x0, 0xc0(%rdi)
leaq 0x4c54(%rip), %rcx      # 0x910a
movl $0x4, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3300
movw $0x0, 0x48(%rbx)
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x6620
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x44f1
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4508
movq (%r13), %rsi
incq %rsi
callq 0x3200
leaq 0x80(%rbx), %rdi
addq $0x18, %rbx
callq 0x6580
movq %r14, %rdi
callq 0x6580
movq %rbx, %rdi
callq 0x65d0
movq %r12, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::print_stackRAM()
void Debugger::print_stackRAM() {
  bool oldHiglight_existed;
  char oldHiglight;

  cerr << "  ----------====== Stack RAM ======---------" << endl;
  uint32_t stackPtr = cpu.getRegister(30);

  oldHiglight_existed = (higlight.count(stackPtr) != 0);
  oldHiglight = (oldHiglight_existed) ? higlight[stackPtr] : ' ';

  higlight[stackPtr] = '>';
  printRAMFrom(stackPtr - 0x10, 12);

  if (oldHiglight_existed) higlight[stackPtr] = oldHiglight;
  else higlight.erase(stackPtr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7a5d(%rip), %r14      # 0xcff0
leaq 0x3c27(%rip), %rsi      # 0x91c1
movl $0x2c, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
movq (%rbx), %rdi
movl $0x1e, %esi
callq 0x3eec
movl %eax, 0x4(%rsp)
movq 0x28(%rbx), %rdx
leaq 0x20(%rbx), %r12
movq %r12, %rcx
testq %rdx, %rdx
je 0x5609
movq %r12, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x55f2
movq %r12, %r13
cmpq %r12, %rcx
je 0x561b
cmpl 0x20(%rcx), %eax
cmovbq %r12, %rcx
movq %rcx, %r13
leaq 0x18(%rbx), %r14
cmpq %r12, %r13
je 0x5636
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x6406
movb (%rax), %bpl
jmp 0x5639
movb $0x20, %bpl
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6406
movb $0x3e, (%rax)
movl (%r15), %esi
addl $-0x10, %esi
movq %rbx, %rdi
movl $0xc, %edx
callq 0x4574
leaq 0x4(%rsp), %rsi
cmpq %r12, %r13
je 0x5676
movq %r14, %rdi
callq 0x6406
movb %bpl, (%rax)
jmp 0x5689
movq %r14, %rdi
callq 0x6932
movq %r14, %rdi
movq %rax, %rsi
callq 0x69aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::print_progRAM()
void Debugger::print_progRAM() {
  bool oldHiglight_existed;
  char oldHiglight;

  cerr << "  ---------====== Program RAM ======--------" << endl;
  uint32_t currentPC = cpu.getPC();

  oldHiglight_existed = (higlight.count(currentPC) != 0);
  oldHiglight = (oldHiglight_existed) ? higlight[currentPC] : ' ';

  higlight[currentPC] = '>';
  uint32_t startAddr = ((int)currentPC - 0x20 >= 0x0)
    ? currentPC - 0x20
    : 0x0;
  printRAMFrom(startAddr, 16);

  if (oldHiglight_existed) higlight[currentPC] = oldHiglight;
  else higlight.erase(currentPC);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7943(%rip), %r14      # 0xcff0
leaq 0x3b3a(%rip), %rsi      # 0x91ee
movl $0x2c, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
movq (%rbx), %rdi
callq 0x3ee4
movl %eax, 0x4(%rsp)
movq 0x28(%rbx), %rdx
leaq 0x20(%rbx), %r12
movq %r12, %rcx
testq %rdx, %rdx
je 0x571e
movq %r12, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x5707
movq %r12, %r13
cmpq %r12, %rcx
je 0x5730
cmpl 0x20(%rcx), %eax
cmovbq %r12, %rcx
movq %rcx, %r13
leaq 0x18(%rbx), %r14
cmpq %r12, %r13
je 0x574b
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x6406
movb (%rax), %bpl
jmp 0x574e
movb $0x20, %bpl
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6406
movb $0x3e, (%rax)
movl (%r15), %eax
leal -0x20(%rax), %ecx
xorl %esi, %esi
cmpl $0x20, %eax
cmovgel %ecx, %esi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x4574
leaq 0x4(%rsp), %rsi
cmpq %r12, %r13
je 0x5793
movq %r14, %rdi
callq 0x6406
movb %bpl, (%rax)
jmp 0x57a6
movq %r14, %rdi
callq 0x6932
movq %r14, %rdi
movq %rax, %rsi
callq 0x69aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daniel5151[P]mips241/src/disasm.cc
// Function: opcode2str[abi:cxx11](unsigned int)
std::string opcode2str(uint32_t opcode) {
  switch (opcode) {
    case OP_ADD:   return "add  ";
    case OP_SUB:   return "sub  ";
    case OP_SLT:   return "slt  ";
    case OP_SLTU:  return "sltu ";
    case OP_MFHI:  return "mfhi ";
    case OP_MFLO:  return "mflo ";
    case OP_MULT:  return "mult ";
    case OP_MULTU: return "multu";
    case OP_DIV:   return "div  ";
    case OP_DIVU:  return "divu ";
    case OP_LIS:   return "lis  ";
    case OP_JR:    return "jr   ";
    case OP_JALR:  return "jalr ";
    case OP_BEQ:   return "beq  ";
    case OP_BNE:   return "bne  ";
    case OP_LW:    return "lw   ";
    case OP_SW:    return "sw   ";
  }
  return "INVALID";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x29, %esi
jg 0x6c53
leal -0x8(%rsi), %eax
cmpl $0x1a, %eax
ja 0x6c7c
leaq 0x284d(%rip), %rcx      # 0x9484
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2957(%rip), %rsi      # 0x959e
leaq 0x2955(%rip), %rdx      # 0x95a3
jmp 0x6db7
cmpl $0xfffffff, %esi        # imm = 0xFFFFFFF
jg 0x6ca3
cmpl $0x2a, %esi
je 0x6d89
cmpl $0x2b, %esi
jne 0x6cca
leaq 0x28fe(%rip), %rsi      # 0x956e
leaq 0x28fc(%rip), %rdx      # 0x9573
jmp 0x6db7
cmpl $0x8c000000, %esi       # imm = 0x8C000000
je 0x6da9
cmpl $0xac000000, %esi       # imm = 0xAC000000
jne 0x6cca
leaq 0x2925(%rip), %rsi      # 0x95bc
leaq 0x2923(%rip), %rdx      # 0x95c1
jmp 0x6db7
cmpl $0x10000000, %esi       # imm = 0x10000000
je 0x6d99
cmpl $0x14000000, %esi       # imm = 0x14000000
jne 0x6cca
leaq 0x28f2(%rip), %rsi      # 0x95b0
leaq 0x28f0(%rip), %rdx      # 0x95b5
jmp 0x6db7
leaq 0x28f1(%rip), %rsi      # 0x95c2
leaq 0x28f1(%rip), %rdx      # 0x95c9
jmp 0x6db7
leaq 0x287e(%rip), %rsi      # 0x9562
leaq 0x287c(%rip), %rdx      # 0x9567
jmp 0x6db7
leaq 0x289b(%rip), %rsi      # 0x9592
leaq 0x2899(%rip), %rdx      # 0x9597
jmp 0x6db7
leaq 0x2882(%rip), %rsi      # 0x958c
leaq 0x2880(%rip), %rdx      # 0x9591
jmp 0x6db7
leaq 0x283f(%rip), %rsi      # 0x955c
leaq 0x283d(%rip), %rdx      # 0x9561
jmp 0x6db7
leaq 0x2850(%rip), %rsi      # 0x9580
leaq 0x284e(%rip), %rdx      # 0x9585
jmp 0x6db7
leaq 0x2858(%rip), %rsi      # 0x9598
leaq 0x2856(%rip), %rdx      # 0x959d
jmp 0x6db7
leaq 0x2824(%rip), %rsi      # 0x9574
leaq 0x2822(%rip), %rdx      # 0x9579
jmp 0x6db7
leaq 0x281a(%rip), %rsi      # 0x957a
leaq 0x2818(%rip), %rdx      # 0x957f
jmp 0x6db7
leaq 0x2834(%rip), %rsi      # 0x95a4
leaq 0x2832(%rip), %rdx      # 0x95a9
jmp 0x6db7
leaq 0x2806(%rip), %rsi      # 0x9586
leaq 0x2804(%rip), %rdx      # 0x958b
jmp 0x6db7
leaq 0x27d8(%rip), %rsi      # 0x9568
leaq 0x27d6(%rip), %rdx      # 0x956d
jmp 0x6db7
leaq 0x280a(%rip), %rsi      # 0x95aa
leaq 0x2808(%rip), %rdx      # 0x95af
jmp 0x6db7
leaq 0x2806(%rip), %rsi      # 0x95b6
leaq 0x2804(%rip), %rdx      # 0x95bb
movq %rbx, %rdi
callq 0x3a82
movq %rbx, %rax
popq %rbx
retq