LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::Matrix(int const&, unsigned long, unsigned long)
Matrix<T>::Matrix(const T& value,
                  const size_t rows,
                  const size_t cols){
    _rows = rows;
    _cols = cols;
    _data = new T[_rows * _cols];
    if(value == 0 || value == static_cast<T>(-1)){
        memset(_data, value, sizeof(T) * _rows * _cols);
    }else{
        auto lambda = [](T* a, const T& b){ *a = b; };
        _po.parallel_mul2one(_data, get_size(), value, lambda);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0xa2ae
movq %r12, (%r13)
movq %rbx, 0x8(%r13)
imulq %r12, %rbx
movq %rbx, %rax
shrq $0x3e, %rax
leaq (,%rbx,4), %r12
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r12, %rdi
callq 0x9030
movq %rax, 0x10(%r13)
movl (%r14), %esi
leal 0x1(%rsi), %ecx
cmpl $0x1, %ecx
ja 0x18339
movq %rax, %rdi
movq %r12, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x91d0
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x6340(%rip), %rcx      # 0x1e68a
movq %rcx, 0x18(%r8)
leaq 0x633d(%rip), %rcx      # 0x1e692
movq %rcx, 0x10(%r8)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18381
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 0x183b3
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x183ab
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<int>::Matrix(abcdl::algebra::Matrix<int> const&)
Matrix(const Matrix<T>& mat){
        _rows = mat.rows();
        _cols = mat.cols();
        _data = new T[_rows * _cols];
        memcpy(_data, mat.data(), sizeof(T) * _rows * _cols);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xa2ae
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %r15
movq %r15, 0x8(%r14)
imulq %rax, %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(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x92b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<int>::clear()
inline void clear(){
        _rows = 0;
        _cols = 0;
        if (_data!= nullptr){
            delete[] _data;
            _data = nullptr;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x184d0
callq 0x9420
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<int>::set_data(int const*, unsigned long, unsigned long)
inline void set_data(const T* data,
                         const size_t rows,
                         const size_t cols){
        if(_rows * _cols != rows * cols){
            if(_data != nullptr){
                delete[] _data;
            }
            _data = new T[rows * cols];
        }
        _rows = rows;
        _cols = cols;
        memcpy(_data, data, sizeof(T) * rows * cols);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rax
imulq (%rdi), %rax
movq 0x10(%rdi), %rdi
movq %rcx, %r13
imulq %rdx, %r13
cmpq %r13, %rax
je 0x18768
testq %rdi, %rdi
je 0x18741
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, %rdi
movq %rax, 0x10(%r12)
movq %r15, (%r12)
movq %r14, 0x8(%r12)
shlq $0x2, %r13
movq %rbx, %rsi
movq %r13, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x92b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::set_shallow_data(int*, unsigned long, unsigned long)
void Matrix<T>::set_shallow_data(T* data,
                                 const size_t rows,
                                 const size_t cols){
    if(_data != nullptr){
        delete[] _data;
    }
    _data = data;
    _rows = rows;
    _cols = cols;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1882a
callq 0x9420
movq %r12, 0x10(%r15)
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18d6a
testq %rbx, %rbx
je 0x18d6a
testq %r15, %r15
je 0x18d6a
cmpq %rbx, %rax
jbe 0x18d6a
cmpq %rbx, %r15
je 0x18d58
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 0x237cf(%rip), %rsi     # 0x3c540
movq %rsp, %r12
movq %r12, %rdi
movl $0x87, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x23844(%rip), %rsi     # 0x3c5d1
movl $0x4f, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x389de
jmp 0x18ccf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18ece
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 0x18e9a
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 0x18e82
movq 0x8(%rsp), %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x18ead
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 0x2366b(%rip), %rsi     # 0x3c540
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x9c, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x2372e(%rip), %rsi     # 0x3c621
movl $0x28, %edx
movq %r13, %rdi
callq 0x93b0
leaq 0x10(%rsp), %rdi
callq 0x389de
jmp 0x18e31
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18fad
movq 0x8(%r15), %r12
leaq (%r12,%rbx), %rax
cmpq 0x8(%r14), %rax
ja 0x18fee
cmpq $0x0, (%r14)
je 0x18f9c
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 0x18f72
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2358c(%rip), %rsi     # 0x3c540
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0xab, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x23678(%rip), %rsi     # 0x3c64a
movl $0x21, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x8(%rsp), %rdi
callq 0x389de
jmp 0x18f4f
leaq 0x2354b(%rip), %rsi     # 0x3c540
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0xac, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x23659(%rip), %rsi     # 0x3c66c
movl $0x2a, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x8(%rsp), %rdi
callq 0x389de
movq 0x8(%r15), %r12
jmp 0x18f61
jmp 0x19035
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1931d
movq 0x8(%rdi), %rsi
jmp 0x18f2e
movq (%rdi), %rsi
jmp 0x18a8c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19431
movq %rcx, %r12
movq %rdx, %r13
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x19407
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 0x19459
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 0x5238(%rip), %rax      # 0x1e6aa
movq %rax, 0x18(%r8)
leaq 0x5235(%rip), %rax      # 0x1e6b2
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x194a6
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 0x194d8
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x194d0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa2ae
movq %rbx, %rdi
callq 0x18250
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x300f6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x18494
movq %r14, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x195a4
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 0x22ea2(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq %r12, %rdi
movl $0x88, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x230ee(%rip), %rsi     # 0x3c6b5
movl $0x28, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x389de
jmp 0x1958b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1963f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x230a6(%rip), %rdi     # 0x3c6de
xorl %eax, %eax
callq 0x9060
cmpq $0x0, (%r15)
je 0x197aa
movl $0xd1b71759, %r12d      # imm = 0xD1B71759
movq $0x0, (%rsp)
movl %ebx, 0xc(%rsp)
testb %bl, %bl
je 0x19671
leaq 0x23084(%rip), %rdi     # 0x3c6ea
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x9060
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x19776
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 0x196e6
movl $0x4, %r14d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0x196dd
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x196e3
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x196e6
movl %eax, %ecx
imulq %r12, %rcx
shrq $0x2d, %rcx
addl $0x4, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x196ad
addl $-0x3, %r14d
jmp 0x196e6
addl $-0x2, %r14d
jmp 0x196e6
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 0x1e4f0
movq 0x18(%rsp), %rsi
leaq 0x22fcd(%rip), %rdi     # 0x3c6f4
xorl %eax, %eax
callq 0x9060
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x1973d
callq 0x9350
movq 0x8(%r15), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %rbp
je 0x19764
movq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x22f9b(%rip), %rdi     # 0x3c6f4
xorl %eax, %eax
callq 0x9060
movq 0x8(%r15), %rax
incq %rbp
cmpq %rax, %rbp
movl $0xd1b71759, %r12d      # imm = 0xD1B71759
jne 0x19680
movl 0xc(%rsp), %ebx
testb %bl, %bl
je 0x1978c
leaq 0x22cc6(%rip), %rdi     # 0x3c44b
callq 0x9500
jmp 0x19796
movl $0xa, %edi
callq 0x9470
movq (%rsp), %rcx
incq %rcx
movq %rcx, (%rsp)
cmpq (%r15), %rcx
jne 0x1965b
testb %bl, %bl
je 0x197ba
leaq 0x22c96(%rip), %rdi     # 0x3c44b
callq 0x9500
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xbb7c
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movsd 0x1c7bd(%rip), %xmm0    # 0x3a010
movups %xmm0, 0x28(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %r15
movq %r15, 0x8(%r14)
imulq %rax, %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(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x92b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd3a8
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 0x1e6c8(%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 0x1de4e
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 0x1de45
callq 0x9420
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xbb7c
pxor %xmm0, %xmm0
movdqu %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %r12
imulq %rbx, %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 %rbx, %rbx
je 0x1e3bb
leaq 0x3(%rbx), %rax
andq $-0x4, %rax
leaq -0x1(%rbx), %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (,%rbx,4), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rbx, %rdx
shlq $0x4, %rdx
addq $0x10, %rdx
movdqa 0x1e1f2(%rip), %xmm1    # 0x3c4d0
movdqa 0x1e1fa(%rip), %xmm2    # 0x3c4e0
movdqa 0x1e202(%rip), %xmm3    # 0x3c4f0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1e202(%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 0x1e33c
movl $0x3f800000, (%rsi)     # imm = 0x3F800000
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x1e353
movl $0x3f800000, 0x4(%rsi,%rbx,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 0x1e393
movl $0x3f800000, 0x8(%rsi,%rbx,8) # imm = 0x3F800000
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x1e3a6
movl $0x3f800000, 0xc(%rsi,%rcx) # imm = 0x3F800000
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq %rdx, %rsi
addq $-0x4, %rax
jne 0x1e301
movq %r15, 0x10(%r14)
movq %rbx, (%r14)
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ee28
movq 0x8(%rsi), %rcx
imulq (%rsi), %rcx
movq 0x8(%rdi), %rax
imulq (%rdi), %rax
cmpq %rcx, %rax
jne 0x1ee2c
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 0x97ff(%rip), %r9       # 0x285ea
movq %r9, 0x18(%rsi)
leaq 0x9800(%rip), %r9       # 0x285f6
movq %r9, 0x10(%rsi)
movq %rsi, (%rsp)
movq %rax, %rsi
movq %rcx, %r9
callq 0xb8d4
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1ee22
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movb 0xf(%rsp), %al
jmp 0x1ee2e
movb $0x1, %al
jmp 0x1ee2e
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1ee5a
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1ee52
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1eeef
movq %rsi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %r13
movq %r13, %r15
imulq %r12, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
imulq (%rbx), %rax
cmpq %r15, %rax
jne 0x1eea9
shlq $0x2, %r15
jmp 0x1eedc
testq %rdi, %rdi
je 0x1eeba
callq 0x9420
movq (%r14), %r12
movq 0x8(%r14), %r13
movq %r15, %rax
shrq $0x3e, %rax
shlq $0x2, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x9030
movq %rax, %rdi
movq %rax, 0x10(%rbx)
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq 0x10(%r14), %rsi
movq %r15, %rdx
callq 0x92b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19326
cmpl $0x0, (%r14)
je 0x1ef6b
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x96d4(%rip), %rax      # 0x2860e
movq %rax, 0x18(%r8)
leaq 0x96d1(%rip), %rax      # 0x28616
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ef6b
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 0x1efa4
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ef94
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x18494
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19326
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x8f80(%rip), %rax      # 0x2868e
movq %rax, 0x18(%r8)
leaq 0x8f7d(%rip), %rax      # 0x28696
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1f73f
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 0x1f778
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1f768
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x18494
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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 0x205c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19326
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x8220(%rip), %rax      # 0x2879e
movq %rax, 0x18(%r8)
leaq 0x8223(%rip), %rax      # 0x287ac
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x205af
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 0x1c528(%rip), %rsi     # 0x3caf0
movq %rsp, %r12
movq %r12, %rdi
movl $0xf4, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x1c5a2(%rip), %rsi     # 0x3cb86
movl $0x18, %edx
movq %r12, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x389de
jmp 0x20552
movq %rax, %r14
movq %rsp, %rdi
callq 0x389de
jmp 0x2062f
jmp 0x20637
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20627
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x18494
movq %r14, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20a0a
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 0x7e9a(%rip), %rax      # 0x28866
movq %rax, 0x18(%r8)
leaq 0x7e9d(%rip), %rax      # 0x28874
movq %rax, 0x10(%r8)
movq %r14, %rcx
callq 0xa56a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x209fa
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 0x1c0df(%rip), %rsi     # 0x3caf0
movq %rsp, %r15
movq %r15, %rdi
movl $0x113, %edx            # imm = 0x113
movl $0x3, %ecx
callq 0x387b6
leaq 0x1c159(%rip), %rsi     # 0x3cb86
movl $0x18, %edx
movq %r15, %rdi
callq 0x93b0
movq %rsp, %rdi
callq 0x389de
jmp 0x209ab
movq %rax, %rbx
movq %rsp, %rdi
callq 0x389de
jmp 0x20a70
jmp 0x20a78
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x20a70
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1826e
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x20eaa
xorl %r15d, %r15d
leaq 0x1b647(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x20e3d
movq 0x10(%r14), %rax
movslq (%rax,%r15,4), %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x20e73
movq 0x10(%rbx), %rax
movl %r15d, (%rax,%r13,4)
incq %r15
cmpq %r15, %rbp
jne 0x20e09
jmp 0x20eaa
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b605(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
movq %r13, %rsi
jmp 0x20e16
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b5d2(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
leaq 0x1b5a5(%rip), %rsi     # 0x3c44d
jmp 0x20e2b
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20ec1
movq %rax, %r14
movq %rsp, %rdi
callq 0x389de
jmp 0x20ed1
movq %rax, %r14
movq %rbx, %rdi
callq 0x18494
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x197fe
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x282d2
xorl %r15d, %r15d
leaq 0x142a9(%rip), %rsi     # 0x3c44d
leaq 0x10(%rsp), %r12
testq %r15, %r15
js 0x281b8
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
jmp 0x281d3
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 0x2825f
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
js 0x281fd
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x28215
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 0x1426f(%rip), %xmm0    # 0x3c498
cvttss2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x28298
movq 0x10(%rbx), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax,%r13,4)
incq %r15
cmpq %r15, %rbp
jne 0x281a9
jmp 0x282d2
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x141e3(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
movq %r13, %rsi
jmp 0x281e6
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x141ad(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
leaq 0x14180(%rip), %rsi     # 0x3c44d
jmp 0x28241
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x282e9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x389de
jmp 0x282fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a36
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ad50
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x2117a
xorl %r15d, %r15d
leaq 0x1b3a9(%rip), %rsi     # 0x3c44d
leaq 0x10(%rsp), %r12
movq %r15, %xmm0
punpckldq 0x1af0a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1af12(%rip), %xmm0    # 0x3bfd0
movapd %xmm0, (%rsp)
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x2110a
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %r13d
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x21140
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 0x210a9
jmp 0x2117a
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b338(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
movq %r13, %rsi
jmp 0x210d0
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b305(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
leaq 0x1b2d8(%rip), %rsi     # 0x3c44d
jmp 0x210e5
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21191
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x389de
jmp 0x211a3
movq %rax, %r14
movq %rbx, %rdi
callq 0x1af8e
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c2a8
movq 0x8(%r14), %rbp
imulq (%r14), %rbp
testq %rbp, %rbp
je 0x21296
xorl %r15d, %r15d
leaq 0x1b25b(%rip), %rsi     # 0x3c44d
movq %rsp, %r12
movq 0x8(%r14), %rax
imulq (%r14), %rax
cmpq %r15, %rax
jbe 0x21229
movq 0x10(%r14), %rax
movslq (%rax,%r15,4), %r13
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq %r13, %rax
jbe 0x2125f
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r13,8)
incq %r15
cmpq %r15, %rbp
jne 0x211f5
jmp 0x21296
movq %r12, %rdi
movq %rsi, %r13
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b219(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
movq %r13, %rsi
jmp 0x21202
movq %r12, %rdi
movl $0x49, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x1e, %edx
movq %r12, %rdi
leaq 0x1b1e6(%rip), %rsi     # 0x3c466
callq 0x93b0
movq %r12, %rdi
callq 0x389de
leaq 0x1b1b9(%rip), %rsi     # 0x3c44d
jmp 0x21217
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x212ad
movq %rax, %r14
movq %rsp, %rdi
callq 0x389de
jmp 0x212bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c4d0
movq %r14, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x8(%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, 0x10(%rsp)
testq %r15, %r15
je 0x29968
movq 0x10(%r13), %rax
movq 0x8(%rsp), %rcx
leaq (,%rcx,4), %rcx
xorl %edx, %edx
movq %rax, %rsi
testq %r14, %r14
je 0x2994d
xorl %r10d, %r10d
movq %rax, %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 0x29936
movq %r11, %r13
movl %r10d, %ebx
incq %r9
addq %rcx, %r8
addq $0x4, %rdi
movl %ebx, %r10d
movq %r13, %r11
cmpq %r9, %r14
jne 0x2990f
jmp 0x29950
xorl %r13d, %r13d
movq 0x10(%rsp), %rdi
movq %r13, (%rdi,%rdx,8)
incq %rdx
addq $0x4, %rsi
addq %rcx, %rax
cmpq %r15, %rdx
jne 0x298fb
testl %ebp, %ebp
movl $0x1, %eax
movq 0x18(%rsp), %r14
cmovneq %rax, %r14
movq 0x8(%rsp), %r15
cmoveq %rax, %r15
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c28a
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1c846
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 0x1c4d0
movq %r14, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x454b(%rip), %rdi      # 0x2e340
movq %rdi, 0x18(%r8)
leaq 0x454c(%rip), %rdi      # 0x2e34c
movq %rdi, 0x10(%r8)
movq %rax, %rdi
callq 0xb1f4
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x29e25
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl 0xc(%rsp), %eax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x29e55
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x29e4d
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x765d(%rip), %rcx      # 0x36072
movq %rcx, 0x18(%rax)
leaq 0x765e(%rip), %rcx      # 0x3607e
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 0xaf68
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2ea58
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 0x18808
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2eaa0
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2ea98
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
imulq (%r12), %rsi
movq (%rdx), %rdx
movq 0x8(%r15), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x2eaf7
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r12, %rdi
movq %rax, %rcx
callq 0x193cc
movq 0x8(%r15), %rcx
imulq (%r15), %rcx
movq 0x10(%r12), %rsi
movq 0x10(%r15), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r9
movaps %xmm0, (%r9)
leaq 0x7585(%rip), %rax      # 0x36096
movq %rax, 0x18(%r9)
leaq 0x7594(%rip), %rax      # 0x360b0
movq %rax, 0x10(%r9)
movq %r14, %rdi
movq %rbx, %r8
callq 0xa8f6
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eb42
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2eb72
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eb6a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
jne 0x2ebc3
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x193cc
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x74ec(%rip), %rax      # 0x360c8
movq %rax, 0x18(%r8)
leaq 0x74f7(%rip), %rax      # 0x360de
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa72a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ec0a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2ec38
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ec30
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91