LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::insert_row(unsigned long, abcdl::algebra::Matrix<int> const&)
void Matrix<T>::insert_row(const size_t row_id, const Matrix<T>& mat){  
    if(get_size() == 0){
        set_data(mat.data(), mat.rows(), mat.cols());
        return;
    }

    CHECK(_cols == mat.cols());

    T* data = new T[(_rows + mat.rows()) * _cols];

    if(row_id > 0){
        memcpy(data, _data, sizeof(T) * row_id * _cols);
    }
    memcpy(&data[row_id * _cols], mat.data(), sizeof(T) * mat.get_size());
    if(row_id < _rows){
        memcpy(&data[(row_id + mat.rows()) * _cols], &_data[row_id * _cols], sizeof(T) * (_rows - row_id) * _cols);
    }
    set_shallow_data(data, _rows + mat.rows(), _cols);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq (%rdi), %rax
imulq %rcx, %rax
testq %rax, %rax
je 0x18e0e
movq %rsi, %rbp
cmpq 0x8(%r15), %rcx
jne 0x18e81
movq (%rbx), %r12
movq 0x8(%rbx), %r13
movq (%r15), %r14
leaq (%r14,%r12), %rax
movq %rax, 0x18(%rsp)
imulq %r13, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
testq %rbp, %rbp
movq %rax, 0x8(%rsp)
je 0x18d74
movq 0x10(%rbx), %rsi
movq %rbp, %rdx
imulq %r13, %rdx
shlq $0x2, %rdx
movq 0x8(%rsp), %rdi
callq 0x92b0
movq 0x8(%rsp), %rax
movq %r13, %rcx
movq %rbp, %r13
movq %rcx, 0x10(%rsp)
movq %rcx, %rbp
imulq %r13, %rbp
leaq (%rax,%rbp,4), %rdi
movq 0x10(%r15), %rsi
movq 0x8(%r15), %rdx
imulq %r14, %rdx
shlq $0x2, %rdx
callq 0x92b0
subq %r13, %r12
jbe 0x18dd4
addq %r13, %r14
movq 0x10(%rsp), %rax
imulq %rax, %r14
movq 0x8(%rsp), %rcx
leaq (%rcx,%r14,4), %rdi
shlq $0x2, %rbp
addq 0x10(%rbx), %rbp
imulq %rax, %r12
shlq $0x2, %r12
movq %rbp, %rsi
movq %r12, %rdx
callq 0x92b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x18de2
callq 0x9420
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %r14
movq (%r15), %r12
movq 0x8(%r15), %r13
movq %r13, %r15
imulq %r12, %r15
cmpq %r15, %rax
je 0x18e56
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x18e33
callq 0x9420
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%rbx)
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x2, %r15
movq %r14, %rsi
movq %r15, %rdx
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x92b0
leaq 0x236b8(%rip), %rsi     # 0x3c540
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl $0x77, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x236de(%rip), %rsi     # 0x3c584
movl $0x21, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x20(%rsp), %rdi
callq 0x38b76
jmp 0x18d1a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x38b76
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::swap_row(unsigned long, unsigned long)
void Matrix<T>::swap_row(const size_t row_id1, const size_t row_id2){
    CHECK(row_id1 < _rows && row_id2 < _rows && row_id1 >=1 && row_id2 >= 1);
    if(row_id1 == row_id2){
        return;
    }
    T* data = new T[_cols];
    memcpy(&data, &_data[row_id1 * _cols], sizeof(T) * _cols);
    memcpy(&_data[row_id1 * _cols], &_data[row_id2 * _cols], sizeof(T) * _cols);
    memcpy(&_data[row_id2 * _cols], &data, sizeof(T) * _cols);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rsi, %rax
jbe 0x18fb4
testq %rbx, %rbx
je 0x18fb4
testq %r15, %r15
je 0x18fb4
cmpq %rbx, %rax
jbe 0x18fb4
cmpq %rbx, %r15
je 0x18fa2
movq 0x8(%r14), %rbp
movq %rbp, %rax
shrq $0x3e, %rax
leaq (,%rbp,4), %r12
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r12, %rdi
callq 0x9030
movq %rsp, %rdi
movq %rax, (%rdi)
movq 0x10(%r14), %r13
imulq %rbp, %r15
leaq (,%r15,4), %r15
addq %r13, %r15
movq %r15, %rsi
movq %r12, %rdx
callq 0x92b0
imulq %rbx, %rbp
leaq (,%rbp,4), %rsi
addq %r13, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x92b0
movq 0x8(%r14), %rdx
imulq %rdx, %rbx
shlq $0x2, %rbx
addq 0x10(%r14), %rbx
shlq $0x2, %rdx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x92b0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23585(%rip), %rsi     # 0x3c540
movq %rsp, %r12
movq %r12, %rdi
movl $0x87, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x235fa(%rip), %rsi     # 0x3c5d1
movl $0x4f, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x38b76
jmp 0x18f19
movq %rax, %rbx
movq %rsp, %rdi
callq 0x38b76
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::get_col(abcdl::algebra::Matrix<int>*, unsigned long, unsigned long) const
void Matrix<T>::get_col(Matrix<T>* mat,
                        const size_t col_id,
                        const size_t col_size) const{
    CHECK(col_id + col_size <= _cols);
	T* data = new T[_rows * col_size];
	for(size_t i = 0; i != _rows; i++){
		memcpy(&data[i * col_size], &_data[i * col_size + col_id], sizeof(T) * col_size);
	}
	mat->set_shallow_data(data, _rows, col_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq (%rcx,%rdx), %rax
cmpq 0x8(%rdi), %rax
ja 0x19118
movq %r14, 0x8(%rsp)
movq (%r12), %r14
movq %r14, %rax
movq %rbx, (%rsp)
imulq %rbx, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %r13
testq %r14, %r14
je 0x190e4
shlq $0x2, %r15
addq 0x10(%r12), %r15
movq (%rsp), %rax
leaq (,%rax,4), %r12
xorl %ebx, %ebx
movq %r14, %rbp
leaq (%rbx,%r13), %rdi
leaq (%r15,%rbx), %rsi
movq %r12, %rdx
callq 0x92b0
addq %r12, %rbx
decq %rbp
jne 0x190cc
movq 0x8(%rsp), %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x190f7
callq 0x9420
movq %r13, 0x10(%rbx)
movq %r14, (%rbx)
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23421(%rip), %rsi     # 0x3c540
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x9c, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x234e4(%rip), %rsi     # 0x3c621
movl $0x28, %edx
movq %r13, %rdi
callq 0x93b0
leaq 0x10(%rsp), %rdi
callq 0x38b76
jmp 0x1907b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x38b76
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::set_col(unsigned long, abcdl::algebra::Matrix<int> const&)
void Matrix<T>::set_col(const size_t col_id, const Matrix<T>& mat){
    CHECK(mat.rows() == _rows);
    CHECK(col_id + mat.cols() <= _cols);
    T* sub_data   = mat.data();
    size_t sub_cols =  mat.cols();

    for(size_t i = 0; i != _rows; i++){
        memcpy(&_data[i * _cols + col_id], &sub_data[i * sub_cols], sizeof(T) * sub_cols);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
cmpq (%rdi), %rax
jne 0x191fa
movq 0x8(%r15), %rax
addq %rbx, %rax
cmpq 0x8(%r14), %rax
ja 0x1923b
cmpq $0x0, (%r14)
je 0x191e9
movq 0x8(%r15), %r12
movq 0x10(%r15), %r15
shlq $0x2, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
imulq %r13, %rax
shlq $0x2, %rax
addq 0x10(%r14), %rax
leaq (%rax,%rbx,4), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x92b0
incq %r13
addq %r12, %r15
cmpq (%r14), %r13
jne 0x191bf
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2333f(%rip), %rsi     # 0x3c540
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0xab, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x2342b(%rip), %rsi     # 0x3c64a
movl $0x21, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x8(%rsp), %rdi
callq 0x38b76
jmp 0x19199
leaq 0x232fe(%rip), %rsi     # 0x3c540
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0xac, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x2340c(%rip), %rsi     # 0x3c66c
movl $0x2a, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x8(%rsp), %rdi
callq 0x38b76
jmp 0x191aa
jmp 0x1927e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x38b76
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::extend(abcdl::algebra::Matrix<int> const&, abcdl::algebra::Axis_type)
void Matrix<T>::extend(const Matrix<T>& mat, const Axis_type type){
    if(type == Axis_type::COL){
        insert_col(mat);
    }else{
        insert_row(mat);
    }
}

// Assembly:
movl %edx, %eax
movq %rsi, %rdx
cmpl $0x1, %eax
jne 0x19575
movq 0x8(%rdi), %rsi
jmp 0x19178
movq (%rdi), %rsi
jmp 0x18ce2
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::reset(int const&, unsigned long, unsigned long)
void Matrix<T>::reset(const T& value,
                      const size_t rows,
                      const size_t cols){
    size_t size = rows * cols;
    if(get_size() != size){
        if(_data != nullptr){
            delete[] _data;
        }
        _data = new T[size];
        _rows = rows;
        _cols = cols;
    }

    if(value == 0 || value == static_cast<T>(-1)){
        memset(_data, value, sizeof(T) * size);
    }else{
        auto lambda = [](T* a, const T& b){ *a = b; };
        _po.parallel_mul2one(_data, size, value, lambda);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rbx
imulq %rdx, %rbx
movq 0x8(%rdi), %rax
imulq (%rdi), %rax
cmpq %rbx, %rax
je 0x1968b
movq %rcx, %r12
movq %rdx, %r13
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x19661
callq 0x9420
movq %rbx, %rax
shrq $0x3e, %rax
leaq (,%rbx,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%r15)
movq %r13, (%r15)
movq %r12, 0x8(%r15)
movl (%r14), %esi
leal 0x1(%rsi), %eax
cmpl $0x1, %eax
ja 0x196b3
movq 0x10(%r15), %rdi
shlq $0x2, %rbx
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x91d0
movq 0x10(%r15), %rsi
addq $0x18, %r15
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x52de(%rip), %rax      # 0x1e9aa
movq %rax, 0x18(%r8)
leaq 0x52db(%rip), %rax      # 0x1e9b2
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa5c8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x19700
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x19732
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1972a
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/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::Ts()
Matrix<T> Matrix<T>::Ts(){
    MatrixHelper<T> mh;
    Matrix<T> mat;
    mh.transpose(mat, *this);
    return mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xa2f2
movq %rbx, %rdi
callq 0x184a8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x302b8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x186ec
movq %r14, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<int>::reshape(unsigned long, unsigned long)
inline Matrix& reshape(const size_t row, const size_t col){
        CHECK(row * col == _rows * _cols);
        _rows = row;
        _cols = col;
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rax
imulq %rsi, %rax
movq 0x8(%rdi), %rcx
imulq (%rdi), %rcx
cmpq %rcx, %rax
jne 0x197fe
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22c48(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq %r12, %rdi
movl $0x88, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x22e94(%rip), %rsi     # 0x3c6b5
movl $0x28, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x38b76
jmp 0x197e5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x38b76
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const
void Matrix<T>::display(const std::string& split, const bool with_title) const{
    if(with_title) printf("[%ld*%ld][\n", _rows, _cols);
    for(size_t i = 0; i != _rows; i++){
        if(with_title) printf("row[%ld][", i);
        for(size_t j = 0; j != _cols; j++){
            printf("%s", std::to_string(_data[i * _cols + j]).c_str());
            if(j != this->_cols - 1){
                printf("%s", split.c_str());
            }
        }
        if(with_title){
            printf("]\n");
        }else{
            printf("\n");
        }
    }
    if(with_title) printf("]\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
testl %edx, %edx
je 0x19899
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x22e4c(%rip), %rdi     # 0x3c6de
xorl %eax, %eax
callq 0x9060
cmpq $0x0, (%r15)
je 0x19a03
movl $0xd1b71759, %r12d      # imm = 0xD1B71759
movq $0x0, (%rsp)
movl %ebx, 0xc(%rsp)
testb %bl, %bl
je 0x198cb
leaq 0x22e2a(%rip), %rdi     # 0x3c6ea
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x9060
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x199cf
xorl %ebp, %ebp
imulq (%rsp), %rax
shlq $0x2, %rax
addq 0x10(%r15), %rax
movl (%rax,%rbp,4), %r13d
movl %r13d, %ebx
negl %ebx
cmovsl %r13d, %ebx
movl $0x1, %r14d
cmpl $0xa, %ebx
jb 0x19940
movl $0x4, %r14d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0x19937
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x1993d
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x19940
movl %eax, %ecx
imulq %r12, %rcx
shrq $0x2d, %rcx
addl $0x4, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x19907
addl $-0x3, %r14d
jmp 0x19940
addl $-0x2, %r14d
jmp 0x19940
decl %r14d
shrl $0x1f, %r13d
movl %r13d, %esi
addl %r14d, %esi
leaq 0x28(%rsp), %r12
movq %r12, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x2d, %edx
callq 0x93c0
movq 0x18(%rsp), %rdi
addq %r13, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x1e7f0
movq 0x18(%rsp), %rsi
leaq 0x22d73(%rip), %rdi     # 0x3c6f4
xorl %eax, %eax
callq 0x9060
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x19997
callq 0x9350
movq 0x8(%r15), %rax
decq %rax
cmpq %rax, %rbp
je 0x199b9
movq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x22d42(%rip), %rdi     # 0x3c6f4
xorl %eax, %eax
callq 0x9060
incq %rbp
movq 0x8(%r15), %rax
cmpq %rax, %rbp
movl $0xd1b71759, %r12d      # imm = 0xD1B71759
jne 0x198da
movl 0xc(%rsp), %ebx
testb %bl, %bl
je 0x199e5
leaq 0x22a6d(%rip), %rdi     # 0x3c44b
callq 0x9500
jmp 0x199ef
movl $0xa, %edi
callq 0x9470
movq (%rsp), %rcx
incq %rcx
movq %rcx, (%rsp)
cmpq (%r15), %rcx
jne 0x198b5
testb %bl, %bl
je 0x19a13
leaq 0x22a3d(%rip), %rdi     # 0x3c44b
callq 0x9500
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::RandomMatrix<float>::RandomMatrix(abcdl::algebra::Matrix<float> const&)
RandomMatrix(const Matrix<T>& mat){
        this->_rows = mat.rows();
        this->_cols = mat.cols();
        this->_data = new T[mat.get_size()];
        memcpy(this->_data, mat.data(), sizeof(T) * mat.get_size());
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0xbc7c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movsd 0x1c562(%rip), %xmm0    # 0x3a010
movups %xmm0, 0x28(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%r14), %r15
imulq (%r14), %r15
movq %r15, %rax
shrq $0x3e, %rax
shlq $0x2, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x9030
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x92b0
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1db0d
callq 0x9420
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::RandomMatrix<double>::RandomMatrix(unsigned long, unsigned long, double const&, double const&, double const&, double const&)
RandomMatrix<T>::RandomMatrix(size_t rows,
                              size_t cols,
                              const T& mean_value,
                              const T& stddev,
                              const T& min,
                              const T& max) : Matrix<T>(rows, cols){
    _mean_value = mean_value;
    _stddev     = stddev;
    _min        = min;
    _max        = max;

    reset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
addq $0x18, %rdi
callq 0xd55a
movq %rbp, (%rbx)
movq %r13, 0x8(%rbx)
imulq %rbp, %r13
movq %r13, %rax
shrq $0x3d, %rax
shlq $0x3, %r13
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r13, %rdi
callq 0x9030
movq %rax, 0x10(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x91d0
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x1e424(%rip), %xmm1    # xmm1 = xmm1[0,1],mem[0,1]
movups %xmm1, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, 0x28(%rbx)
movsd (%r15), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x1e0f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e0e9
callq 0x9420
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::RandomMatrix<float>::reset(unsigned long, unsigned long, float const&, float const&, float const&, float const&)
void RandomMatrix<T>::reset(size_t rows,
                            size_t cols,
                            const T& mean_value,
                            const T& stddev,
                            const T& min,
                            const T& max){
    if(rows * cols != this->_rows * this->_cols){
        if(this->_data != nullptr){
            delete[] this->_data;
        }
        this->_data = new T[rows * cols];
    }

    this->_rows = rows;
    this->_cols = cols;
    _mean_value = mean_value;
    _stddev     = stddev;
    _min        = min;
    _max        = max;

    reset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
movq %rdx, %r13
imulq %rsi, %r13
movq 0x8(%rdi), %rax
imulq (%rdi), %rax
cmpq %rax, %r13
je 0x1df08
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1dedf
callq 0x9420
movq %r13, %rax
shrq $0x3e, %rax
shlq $0x2, %r13
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r13, %rdi
callq 0x9030
movq %rax, 0x10(%r14)
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %r8
movq %rbp, (%r14)
movq %r15, 0x8(%r14)
movss (%r12), %xmm0
movss %xmm0, 0x28(%r14)
movss (%r8), %xmm0
movss %xmm0, 0x2c(%r14)
movss (%r9), %xmm0
movss %xmm0, 0x30(%r14)
movss (%rbx), %xmm0
movss %xmm0, 0x34(%r14)
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dbe4
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::EyeMatrix<float>::EyeMatrix(unsigned long)
explicit EyeMatrix(const size_t size){
        T* data = new T[size * size];
        memset(data, 0, sizeof(T) * size * size);
        T value = 1;
        for(size_t i = 0; i != size; i++){
            data[i * size + i] = value;
        }
        this->set_shallow_data(data, size, size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0xbc7c
pxor %xmm0, %xmm0
movdqu %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %r12
imulq %r14, %r12
movq %r12, %rax
shrq $0x3e, %rax
shlq $0x2, %r12
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r12, %rdi
callq 0x9030
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x91d0
testq %r14, %r14
je 0x1e65e
leaq 0x3(%r14), %rax
andq $-0x4, %rax
leaq -0x1(%r14), %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (,%r14,4), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %r14, %rdx
shlq $0x4, %rdx
addq $0x10, %rdx
movdqa 0x1df51(%rip), %xmm1    # 0x3c4d0
movdqa 0x1df59(%rip), %xmm2    # 0x3c4e0
movdqa 0x1df61(%rip), %xmm3    # 0x3c4f0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1df61(%rip), %xmm5    # 0x3c500
movq %r15, %rsi
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x1e5dd
movl $0x3f800000, (%rsi)     # imm = 0x3F800000
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x1e5f5
movl $0x3f800000, 0x4(%rsi,%r14,4) # imm = 0x3F800000
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edi
testb $0x1, %dil
je 0x1e636
movl $0x3f800000, 0x8(%rsi,%r14,8) # imm = 0x3F800000
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x1e649
movl $0x3f800000, 0xc(%rsi,%rcx) # imm = 0x3F800000
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq %rdx, %rsi
addq $-0x4, %rax
jne 0x1e5a2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e66c
callq 0x9420
movq %r15, 0x10(%rbx)
movq %r14, (%rbx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e69c
callq 0x9420
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator==(abcdl::algebra::Matrix<int> const&) const
bool Matrix<T>::operator == (const Matrix<T>& mat) const{
	if(this == &mat){
		return true;
	}
    size_t size = mat.get_size();
	if(get_size() != size){
		return false;
	}

    bool result_value = true;
    auto lambda = [](bool* a, const T& b, const T& c){*a = (b == c);};
    _po.parallel_reduce_boolean(&result_value, _data, get_size(), mat.data(), size, lambda);
	return result_value;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpq %rsi, %rdi
je 0x1f125
movq 0x8(%rsi), %r9
imulq (%rsi), %r9
movq 0x8(%rdi), %rcx
imulq (%rdi), %rcx
cmpq %r9, %rcx
jne 0x1f129
leaq 0xf(%rsp), %rax
movb $0x1, (%rax)
movq 0x10(%rdi), %rdx
addq $0x18, %rdi
movq 0x10(%rsi), %r8
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x9667(%rip), %r10      # 0x28752
movq %r10, 0x18(%rsi)
leaq 0x9668(%rip), %r10      # 0x2875e
movq %r10, 0x10(%rsi)
movq %rsi, (%rsp)
movq %rax, %rsi
callq 0xb9c4
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1f11f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movb 0xf(%rsp), %al
jmp 0x1f12b
movb $0x1, %al
jmp 0x1f12b
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1f157
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1f14f
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/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator=(abcdl::algebra::Matrix<int> const&)
Matrix<T>& Matrix<T>::operator = (const Matrix<T>& mat){
    if(this != &mat){
        size_t size = mat.get_size();
        if(get_size() != size){
            if(_data != nullptr){
                delete[] _data;
            }
        	_data = new T[size];
        }

        _rows = mat.rows();
        _cols = mat.cols();
        memcpy(_data, mat.data(), sizeof(T) * size);

	}
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1f1df
movq %rsi, %r14
movq 0x8(%rsi), %r15
imulq (%rsi), %r15
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r15, %rax
je 0x1f1c4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1f1a1
callq 0x9420
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x2, %r15
movq %r15, %rdx
callq 0x92b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator+(int const&) const
Matrix<T> Matrix<T>::operator + (const T& value) const{
    auto new_mat = clone();
    if (value != 0){
        auto lambda = [](T* a, const T& b){*a += b;};
        _po.parallel_mul2one(new_mat.data(), new_mat.get_size(), value, lambda);
    }
    return new_mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1957e
cmpl $0x0, (%r14)
je 0x1f257
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x9550(%rip), %rax      # 0x28776
movq %rax, 0x18(%r8)
leaq 0x954d(%rip), %rax      # 0x2877e
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa5c8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1f257
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1f290
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1f280
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x186ec
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator-(int const&) const
Matrix<T> Matrix<T>::operator - (const T& value) const{
    auto lambda = [](T* a, const T& b){*a -= b;};
    auto new_mat = clone();
    _po.parallel_mul2one(new_mat.data(), new_mat.get_size(), value, lambda);
    return new_mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1957e
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x8dfe(%rip), %rax      # 0x287f6
movq %rax, 0x18(%r8)
leaq 0x8dfb(%rip), %rax      # 0x287fe
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa5c8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1fa29
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1fa62
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1fa52
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x186ec
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/(int const&) const
Matrix<T> Matrix<T>::operator / (const T& value) const{
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    auto new_mat = clone();
    _po.parallel_mul2one(new_mat.data(), new_mat.get_size(), value, lambda);
    return new_mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, (%rdx)
je 0x2089b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1957e
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x80ae(%rip), %rax      # 0x28906
movq %rax, 0x18(%r8)
leaq 0x80b1(%rip), %rax      # 0x28914
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa5c8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20889
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c24e(%rip), %rsi     # 0x3caf0
movq %rsp, %r12
movq %r12, %rdi
movl $0xf4, %edx
movl $0x3, %ecx
callq 0x3894e
leaq 0x1c2c8(%rip), %rsi     # 0x3cb86
movl $0x18, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x38b76
jmp 0x2082c
movq %rax, %r14
movq %rsp, %rdi
callq 0x38b76
jmp 0x20909
jmp 0x20911
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20901
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x186ec
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/=(int const&)
Matrix<T>& Matrix<T>::operator /= (const T& value){
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    _po.parallel_mul2one(_data, get_size(), value, lambda);
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x20ce0
leaq 0x18(%rbx), %rdi
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x7d28(%rip), %rax      # 0x289ca
movq %rax, 0x18(%r8)
leaq 0x7d2b(%rip), %rax      # 0x289d8
movq %rax, 0x10(%r8)
movq %r14, %rcx
callq 0xa5c8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20cd0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1be09(%rip), %rsi     # 0x3caf0
movq %rsp, %r15
movq %r15, %rdi
movl $0x113, %edx            # imm = 0x113
movl $0x3, %ecx
callq 0x3894e
leaq 0x1be83(%rip), %rsi     # 0x3cb86
movl $0x18, %edx
movq %r15, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x38b76
jmp 0x20c81
movq %rax, %rbx
movq %rsp, %rdi
callq 0x38b76
jmp 0x20d46
jmp 0x20d4e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20d46
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/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<int>() const
Matrix<T>::operator Matrix<int>() const{
    Matrix<int> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<int>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x184c6
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x21174
xorl %r15d, %r15d
leaq 0x1b37d(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x21107
movq 0x10(%r14), %rax
movslq (%rax,%r15,4), %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x2113d
movq 0x10(%rbx), %rax
movl %r15d, (%rax,%r13,4)
incq %r15
cmpq %r15, %rbp
jne 0x210d3
jmp 0x21174
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b33b(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
movq %r13, %rsi
jmp 0x210e0
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b308(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
leaq 0x1b2db(%rip), %rsi     # 0x3c44d
jmp 0x210f5
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2118b
movq %rax, %r14
movq %rsp, %rdi
callq 0x38b76
jmp 0x2119b
movq %rax, %r14
movq %rbx, %rdi
callq 0x186ec
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<unsigned long>::operator abcdl::algebra::Matrix<float>() const
Matrix<T>::operator Matrix<float>() const{
    Matrix<float> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<float>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x19a56
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x2843a
xorl %r15d, %r15d
leaq 0x14141(%rip), %rsi     # 0x3c44d
leaq 0x10(%rsp), %r12
testq %r15, %r15
js 0x28320
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
jmp 0x2833b
movq %r15, %rax
shrq %rax
movl %r15d, %ecx
andl $0x1, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x283c7
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
js 0x28365
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x2837d
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x14107(%rip), %xmm0    # 0x3c498
cvttss2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x28400
movq 0x10(%rbx), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax,%r13,4)
incq %r15
cmpq %r15, %rbp
jne 0x28311
jmp 0x2843a
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1407b(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
movq %r13, %rsi
jmp 0x2834e
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x14045(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
leaq 0x14018(%rip), %rsi     # 0x3c44d
jmp 0x283a9
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28451
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x38b76
jmp 0x28463
movq %rax, %r14
movq %rbx, %rdi
callq 0x19c8e
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<double>() const
Matrix<T>::operator Matrix<double>() const{
    Matrix<double> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<double>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x1afa8
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x21444
xorl %r15d, %r15d
leaq 0x1b0df(%rip), %rsi     # 0x3c44d
leaq 0x10(%rsp), %r12
movq %r15, %xmm0
punpckldq 0x1ac40(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1ac48(%rip), %xmm0    # 0x3bfd0
movapd %xmm0, (%rsp)
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x213d4
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %r13d
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x2140a
movapd (%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r15
cmpq %r15, %rbp
jne 0x21373
jmp 0x21444
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b06e(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
movq %r13, %rsi
jmp 0x2139a
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b03b(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
leaq 0x1b00e(%rip), %rsi     # 0x3c44d
jmp 0x213af
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2145b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x38b76
jmp 0x2146d
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b1e6
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<unsigned long>() const
Matrix<T>::operator Matrix<size_t>() const{
    Matrix<size_t> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<size_t>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x1c502
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x21560
xorl %r15d, %r15d
leaq 0x1af91(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x214f3
movq 0x10(%r14), %rax
movslq (%rax,%r15,4), %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x21529
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r13,8)
incq %r15
cmpq %r15, %rbp
jne 0x214bf
jmp 0x21560
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1af4f(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
movq %r13, %rsi
jmp 0x214cc
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x3894e
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1af1c(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x38b76
leaq 0x1aeef(%rip), %rsi     # 0x3c44d
jmp 0x214e1
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21577
movq %rax, %r14
movq %rsp, %rdi
callq 0x38b76
jmp 0x21587
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c72a
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::argmax(abcdl::algebra::Axis_type) const
Matrix<size_t> Matrix<T>::argmax(Axis_type axis_type) const{
    size_t size = (axis_type == Axis_type::ROW)? _rows : _cols;
   	size_t end_idx = (axis_type == Axis_type::ROW) ? _cols : _rows;
    size_t* idx_data = new size_t[size];
    for(size_t i = 0; i != size; i++){
        T max_value = 0;
        size_t max_idx = 0;
        for(size_t j = 0; j != end_idx; j++){
            T value = (axis_type == Axis_type::ROW) ? _data[i * _cols + j] : _data[j * _cols + i];
            if( j == 0 || value > max_value){
                max_value = value;
                max_idx = j;
            }
        }
        idx_data[i] = max_idx;
    }

    size_t rows = (axis_type == Axis_type::ROW) ? size : 1;
    size_t cols = (axis_type == Axis_type::ROW) ? 1 : size;

	abcdl::algebra::Matrix<size_t> mat;
	mat.set_shallow_data(idx_data, rows, cols);

    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r13
testl %edx, %edx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq %rax, %r15
cmoveq %r14, %r15
movq %rdi, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movq %rax, 0x10(%rsp)
cmoveq %rax, %r14
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x29aa7
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
shlq $0x2, %rax
xorl %edx, %edx
movq %rcx, %rsi
testq %r14, %r14
je 0x29a8c
xorl %r10d, %r10d
movq %rcx, %rdi
movq %rsi, %r8
xorl %r11d, %r11d
xorl %r9d, %r9d
testl %ebp, %ebp
movq %r8, %rbx
cmoveq %rdi, %rbx
movl (%rbx), %ebx
testq %r9, %r9
sete %r13b
cmpl %r10d, %ebx
setg %r12b
orb %r13b, %r12b
movq %r9, %r13
jne 0x29a75
movq %r11, %r13
movl %r10d, %ebx
incq %r9
addq %rax, %r8
addq $0x4, %rdi
movl %ebx, %r10d
movq %r13, %r11
cmpq %r9, %r14
jne 0x29a4e
jmp 0x29a8f
xorl %r13d, %r13d
movq 0x8(%rsp), %rdi
movq %r13, (%rdi,%rdx,8)
incq %rdx
addq $0x4, %rsi
addq %rax, %rcx
cmpq %r15, %rdx
jne 0x29a3a
testl %ebp, %ebp
movl $0x1, %eax
movq 0x18(%rsp), %r14
cmovneq %rax, %r14
movq 0x10(%rsp), %r15
cmoveq %rax, %r15
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c4e4
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1caa0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c72a
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::sum() const
T Matrix<T>::sum() const{
	T sum = 0;
	auto lambda = [](T* a, const T& b){if(b != 0){ *a += b;} };
	_po.parallel_reduce_mul2one(&sum, _data, get_size(), lambda);
	return sum;   
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x18(%rdi), %rax
movq 0x8(%rdi), %rcx
imulq (%rdi), %rcx
movq 0x10(%rdi), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x45f5(%rip), %rdi      # 0x2e50e
movq %rdi, 0x18(%r8)
leaq 0x45f6(%rip), %rdi      # 0x2e51a
movq %rdi, 0x10(%r8)
movq %rax, %rdi
callq 0xb2b4
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x29f49
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl 0xc(%rsp), %eax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x29f79
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x29f71
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>::outer(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::outer(Matrix<T>& mat,
							const Matrix<T>& mat_a,
							const Matrix<T>& mat_b){
    size_t size_a = mat_a.get_size();
    size_t size_b = mat_b.get_size();
    T* data_a = mat_a.data();
    T* data_b = mat_b.data();
    T* data   = new T[size_a * size_b];
    auto lambda = [](T* a, const T& b, const T& c){*a = b * c;};
    _po.parallel_mul2mul_cross(data, data_a, size_a, data_b, size_b, lambda);
    mat.set_shallow_data(data, size_a, size_b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq 0x8(%rdx), %rbx
movq 0x10(%rdx), %rbp
imulq (%rdx), %rbx
movq 0x8(%rcx), %r15
movq 0x10(%rcx), %r14
imulq (%rcx), %r15
movq %r15, %rax
imulq %rbx, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x7623(%rip), %rcx      # 0x36222
movq %rcx, 0x18(%rax)
leaq 0x7624(%rip), %rcx      # 0x3622e
movq %rcx, 0x10(%rax)
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
callq 0xb014
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2ec42
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x18a60
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ec8a
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2ec82
leaq 0x10(%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>::pow(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, int const&)
void MatrixHelper<T>::pow(Matrix<T>& mat,
						  const Matrix<T>& mat_a,
						  const T& exponent){
    auto lambda = [](T* a, const T& b, const T& c){*a = std::pow(b, c);};
    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(), exponent, lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rax
imulq (%rsi), %rax
movq (%rdx), %rdx
movq 0x8(%r15), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
je 0x2ecd5
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r12, %rdi
callq 0x19626
movq 0x10(%r12), %rsi
movq 0x8(%r15), %rcx
imulq (%r15), %rcx
movq 0x10(%r15), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r9
movaps %xmm0, (%r9)
leaq 0x754f(%rip), %rax      # 0x36246
movq %rax, 0x18(%r9)
leaq 0x755e(%rip), %rax      # 0x36260
movq %rax, 0x10(%r9)
movq %r14, %rdi
movq %rbx, %r8
callq 0xa974
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ed28
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2ed58
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ed50
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>::log(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::log(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::log(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
jne 0x2ed9e
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 0x74b9(%rip), %rax      # 0x36278
movq %rax, 0x18(%r8)
leaq 0x74c4(%rip), %rax      # 0x3628e
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa798
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eded
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2ee1b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ee13
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x112c8
nop