LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/fnn/FNN.cpp
// Function: abcdl::fnn::FNN::predict(abcdl::algebra::Matrix<float>&, abcdl::algebra::Matrix<float> const&)
void FNN::predict(abcdl::algebra::Mat& result, const abcdl::algebra::Mat& predict_data){
    CHECK(predict_data.cols() == _layers[0]->get_input_dim());
    size_t layer_size = _layers.size();
    for(size_t k = 0; k < layer_size; k++){
        if(k == 0){
            ((InputLayer*)_layers[k])->set_x(predict_data);
        }
        _layers[k]->forward(_layers[k-1]);
        if(k > 0){
            //_layers[k]->get_activate_data().display("|");
        }
    }
    //predict_data.display("^");
    //_layers[layer_size - 1]->get_activate_data().display("|");
    result = _layers[layer_size - 1]->get_activate_data();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rcx
movq 0x30(%rdi), %rax
movq (%rax), %rdx
cmpq 0x8(%rdx), %rcx
jne 0x14e48
movq 0x38(%r15), %r12
subq %rax, %r12
movq %r12, %r13
sarq $0x3, %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x14e20
movq 0x30(%r15), %rax
testq %rbp, %rbp
jne 0x14e0c
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1388c
movq 0x30(%r15), %rax
movq -0x8(%rax,%rbp,8), %rsi
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
incq %rbp
jmp 0x14def
movq 0x30(%r15), %rax
movl $0xa0, %esi
addq -0x8(%rax,%r12), %rsi
movq %rbx, %rdi
callq 0x1dee2
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d181(%rip), %rsi     # 0x31fd0
movq %rsp, %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0x86, %edx
callq 0x2ee18
leaq 0x1d3fa(%rip), %rsi     # 0x32263
movq %r12, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
movq 0x30(%r15), %rax
jmp 0x14ddf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/fnn/FNN.cpp
// Function: abcdl::fnn::FNN::write_model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool FNN::write_model(const std::string& path){
    std::vector<abcdl::algebra::Mat*> params;
    for(size_t i = 1; i != _layers.size(); i++){
        params.push_back(&_layers[i]->get_weight());
        params.push_back(&_layers[i]->get_bias());
    }
    return _model_loader.write<real>(params, path, "FNNMODEL", false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
pushq $0x1
popq %r13
leaq 0x10(%rsp), %r12
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
je 0x15324
movq (%rax,%r13,8), %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1686e
movq 0x30(%r14), %rax
movq (%rax,%r13,8), %rax
addq $0x68, %rax
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1686e
incq %r13
jmp 0x152d7
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x160ea
leaq 0x1cf7e(%rip), %rsi     # 0x322b8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9120
addq $0x50, %r14
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x15e06
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x9160
leaq 0x48(%rsp), %rdi
callq 0x164c4
leaq 0x30(%rsp), %rdi
callq 0x164c4
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9160
jmp 0x153a7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x164c4
jmp 0x153ba
jmp 0x153b7
jmp 0x153b7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x164c4
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::update_gradient(unsigned long, float)
void update_gradient(const size_t batch_size,
                         const real learning_rate){
		real lr = learning_rate / batch_size;
        _weight -= _batch_weight * lr;
        _bias   -= _batch_bias * lr;
        
		_batch_weight.reset(0);
        _batch_bias.reset(0);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
js 0x15798
cvtsi2ss %rsi, %xmm1
jmp 0x157ad
movq %rsi, %rax
shrq %rax
andl $0x1, %esi
orq %rax, %rsi
cvtsi2ss %rsi, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
leaq 0xc(%rsp), %rdx
movss %xmm0, (%rdx)
leaq 0x118(%rbx), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e7f4
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x1e662
leaq 0x10(%rsp), %rdi
callq 0x17fd6
leaq 0x140(%rbx), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e7f4
addq $0x68, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e662
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x17fd6
andl $0x0, (%rbx)
leaq 0x10(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18c44
andl $0x0, (%rbx)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x18c44
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x15850
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x17fd6
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::set_weight(abcdl::algebra::Matrix<float> const&)
bool set_weight(const abcdl::algebra::Mat& weight){
        if(weight.rows() != _weight.rows()){
            LOG(FATAL) << "set weight rows error:" << weight.rows() << " must be:" << _weight.rows();
            return false;
        }
        if(weight.cols() != _weight.cols()){
            LOG(FATAL) << "set weight cols error:" << weight.cols() << " must be:" << _weight.cols();
            return false;
        }
        _weight = weight;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x30(%rdi), %r14
cmpq 0x30(%rdi), %rax
jne 0x15c01
movq %rdi, %r15
movq 0x8(%rbx), %rax
cmpq 0x38(%rdi), %rax
jne 0x15c57
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16138
movb $0x1, %al
jmp 0x15cb9
leaq 0x1c759(%rip), %rsi     # 0x32361
leaq 0x8(%rsp), %r15
pushq $0x31
popq %rdx
pushq $0x3
popq %rcx
movq %r15, %rdi
callq 0x2ee18
leaq 0x1c753(%rip), %rsi     # 0x32375
movq %r15, %rdi
callq 0x9370
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x1c6aa(%rip), %rsi     # 0x322e8
leaq 0x8(%rsp), %rdi
callq 0x9370
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
jmp 0x15cad
leaq 0x1c703(%rip), %rsi     # 0x32361
leaq 0x8(%rsp), %r14
pushq $0x35
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
callq 0x2ee18
leaq 0x1c714(%rip), %rsi     # 0x3238c
movq %r14, %rdi
callq 0x9370
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x1c653(%rip), %rsi     # 0x322e8
leaq 0x8(%rsp), %rdi
callq 0x9370
movq 0x38(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x8(%rsp), %rdi
callq 0x2f054
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
jmp 0x15cd0
jmp 0x15cd0
jmp 0x15cd0
jmp 0x15cd0
jmp 0x15cd0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::set_bias(abcdl::algebra::Matrix<float> const&)
bool set_bias(const abcdl::algebra::Mat& bias){
        if(bias.rows() != _bias.rows()){
            LOG(FATAL) << "set bias rows error:" << bias.rows() << " must be:" << _bias.rows();
            return false;
        }
        if(bias.cols() != _bias.cols()){
            LOG(FATAL) << "set bias cols error:" << bias.cols() << " must be:" << _bias.cols();
            return false;
        }
        _bias = bias;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x68(%rdi), %r14
cmpq 0x68(%rdi), %rax
jne 0x15d21
movq %rdi, %r15
movq 0x8(%rbx), %rax
cmpq 0x70(%rdi), %rax
jne 0x15d77
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16138
movb $0x1, %al
jmp 0x15dd9
leaq 0x1c639(%rip), %rsi     # 0x32361
leaq 0x8(%rsp), %r15
pushq $0x3f
popq %rdx
pushq $0x3
popq %rcx
movq %r15, %rdi
callq 0x2ee18
leaq 0x1c661(%rip), %rsi     # 0x323a3
movq %r15, %rdi
callq 0x9370
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x1c58a(%rip), %rsi     # 0x322e8
leaq 0x8(%rsp), %rdi
callq 0x9370
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
jmp 0x15dcd
leaq 0x1c5e3(%rip), %rsi     # 0x32361
leaq 0x8(%rsp), %r14
pushq $0x43
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
callq 0x2ee18
leaq 0x1c620(%rip), %rsi     # 0x323b8
movq %r14, %rdi
callq 0x9370
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x1c533(%rip), %rsi     # 0x322e8
leaq 0x8(%rsp), %rdi
callq 0x9370
movq 0x70(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9210
leaq 0x8(%rsp), %rdi
callq 0x2f054
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
jmp 0x15df0
jmp 0x15df0
jmp 0x15df0
jmp 0x15df0
jmp 0x15df0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::RandomMatrix<float>::operator=(abcdl::algebra::Matrix<float> const&)
RandomMatrix<T>& operator = (const Matrix<T>& mat){
        if(this->get_size() != mat.get_size()){
            if(this->_data != nullptr){
                delete[] this->_data;
            }
            this->_data = new T[mat.get_size()];
        }
        this->_rows = mat.rows();
        this->_cols = mat.cols();
        memcpy(this->_data, mat.data(), sizeof(T) * mat.get_size());

        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
imulq (%rbx), %rcx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %r12, %rax
imulq %r15, %rax
cmpq %rax, %rcx
je 0x1619f
testq %rdi, %rdi
je 0x1617d
callq 0x9420
movq (%r14), %r15
movq 0x8(%r14), %r12
movq %r12, %rax
imulq %r15, %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, %rdi
movq %rax, 0x10(%rbx)
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq 0x10(%r14), %rsi
imulq 0x8(%r14), %rdx
shlq $0x2, %rdx
callq 0x92c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/ModelLoader.h
// Function: bool abcdl::utils::ModelLoader::generate_header<float>(std::vector<abcdl::algebra::Matrix<float>*, std::allocator<abcdl::algebra::Matrix<float>*>>, std::vector<abcdl::utils::ModelInfo, std::allocator<abcdl::utils::ModelInfo>>*)
bool ModelLoader::generate_header(const std::vector<abcdl::algebra::Matrix<T>*> models,
                                  std::vector<ModelInfo>* infos){
    for(auto&& model : models){
        ModelInfo info;
        info.rows = model->rows();
        info.cols = model->cols();
        if(typeid(T) == typeid(int)){
            info.type = 'i';
        }else if(typeid(T) == typeid(float)){
            info.type = 'f';
        }else if(typeid(T) == typeid(double)){
            info.type = 'd';
        }else{
            LOG(FATAL) << "ModelLoader not support data type";
            return false;
        }
        infos->push_back(info);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movq (%rsi), %rbp
movq 0x8(%rsi), %r13
movq 0x38660(%rip), %r14     # 0x4efd0
movq 0x38621(%rip), %r15     # 0x4ef98
leaq 0x8(%rsp), %r12
cmpq %r13, %rbp
je 0x16a1b
movq (%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x16aca
testb %al, %al
je 0x169a7
movb $0x69, 0x8(%rsp)
jmp 0x169d5
movq %r14, %rdi
movq %r14, %rsi
callq 0x16aca
testb %al, %al
je 0x169bd
movb $0x66, 0x8(%rsp)
jmp 0x169d5
movq %r14, %rdi
movq 0x38629(%rip), %rsi     # 0x4eff0
callq 0x16aca
testb %al, %al
je 0x169e6
movb $0x64, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16552
addq $0x8, %rbp
jmp 0x1697c
leaq 0x1b9e0(%rip), %rsi     # 0x323cd
leaq 0x20(%rsp), %rbx
pushq $0x3
popq %rcx
movq %rbx, %rdi
movl $0xde, %edx
callq 0x2ee18
leaq 0x1ba24(%rip), %rsi     # 0x3242d
movq %rbx, %rdi
callq 0x9370
leaq 0x20(%rsp), %rdi
callq 0x2f054
cmpq %r13, %rbp
sete %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::Matrix(unsigned long, unsigned long)
Matrix<T>::Matrix(const size_t rows, const size_t cols){
    _rows = rows;
    _cols = cols;
    _data = new T[_rows * _cols];
    memset(_data, 0, sizeof(T) * _rows * _cols);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rdi
callq 0x9f20
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
imulq %r14, %rbx
movq %rbx, %rax
shrq $0x3e, %rax
shlq $0x2, %rbx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbx, %rdi
callq 0x9030
movq %rax, 0x10(%r15)
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x91e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9f20
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 0x16bfd
movq %rax, %rdi
movq %r12, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x91e0
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x55e8(%rip), %rcx      # 0x1c1f6
movq %rcx, 0x18(%r8)
leaq 0x55e5(%rip), %rcx      # 0x1c1fe
movq %rcx, 0x10(%r8)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::Matrix(int const*, unsigned long, unsigned long)
Matrix<T>::Matrix(const T* data,
                  const size_t rows,
                  const size_t cols){
    _rows = rows;
    _cols = cols;
    _data = new T[_rows * _cols];
    memcpy(_data, data, sizeof(T) * _rows * _cols);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x18, %rdi
callq 0x9f20
movq %r14, (%r12)
movq %rbx, 0x8(%r12)
imulq %r14, %rbx
movq %rbx, %rax
shrq $0x3e, %rax
shlq $0x2, %rbx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbx, %rdi
callq 0x9030
movq %rax, 0x10(%r12)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x92c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16d67
callq 0x9420
andq $0x0, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16fdc
testq %rdi, %rdi
je 0x16fb5
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 0x92c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17034
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_O2/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::get_row(abcdl::algebra::Matrix<int>*, unsigned long, unsigned long) const
void Matrix<T>::get_row(Matrix<T>* mat,
                        const size_t row_id,
                        const size_t row_size) const{
    CHECK(row_id + row_size <= _rows);
	T* data = new T[row_size * _cols];
	memcpy(data, &_data[row_id * _cols], sizeof(T) * row_size * _cols);
	mat->set_shallow_data(data, row_size, _cols);
}

// 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, 0x8(%rsp)
movq %rdi, %r12
leaq (%rcx,%rdx), %rax
cmpq (%rdi), %rax
ja 0x1712a
movq 0x8(%r12), %r13
movq %r13, %rbp
imulq %rbx, %rbp
movq %rbp, %rax
shrq $0x3e, %rax
shlq $0x2, %rbp
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbp, %rdi
callq 0x9030
movq %rax, %r14
imulq %r13, %r15
shlq $0x2, %r15
addq 0x10(%r12), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x92c0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x17012
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b3b7(%rip), %rsi     # 0x324e8
leaq 0x10(%rsp), %r13
pushq $0x5a
popq %rdx
pushq $0x3
popq %rcx
movq %r13, %rdi
callq 0x2ee18
leaq 0x1b3b8(%rip), %rsi     # 0x32503
movq %r13, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
jmp 0x170c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %r15
movq (%rdi), %r13
movq 0x8(%rdi), %r14
movq %r14, %rax
imulq %r13, %rax
testq %rax, %rax
je 0x17390
movq %rsi, 0x8(%rsp)
cmpq 0x8(%r12), %r14
jne 0x173b7
movq (%r12), %rbx
leaq (%rbx,%r13), %rax
movq %rax, 0x18(%rsp)
imulq %r14, %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, %rbp
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x172ff
movq 0x10(%r15), %rsi
movq 0x8(%rsp), %rdx
imulq %r14, %rdx
shlq $0x2, %rdx
movq %rbp, %rdi
callq 0x92c0
movq 0x8(%rsp), %rax
movq %r15, 0x10(%rsp)
movq %r14, %r15
imulq %rax, %r15
leaq (,%r15,4), %rdi
addq %rbp, %rdi
movq 0x10(%r12), %rsi
movq 0x8(%r12), %rdx
imulq %rbx, %rdx
shlq $0x2, %rdx
callq 0x92c0
movq 0x8(%rsp), %rax
subq %rax, %r13
jbe 0x17369
addq %rax, %rbx
imulq %r14, %rbx
leaq (,%rbx,4), %rdi
addq %rbp, %rdi
shlq $0x2, %r15
movq 0x10(%rsp), %rax
addq 0x10(%rax), %r15
imulq %r14, %r13
shlq $0x2, %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x92c0
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
callq 0x17012
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r12), %rsi
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %r15, %rdi
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16f7e
leaq 0x1b12a(%rip), %rsi     # 0x324e8
leaq 0x20(%rsp), %r14
pushq $0x77
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
callq 0x2ee18
leaq 0x1b154(%rip), %rsi     # 0x3252c
movq %r14, %rdi
callq 0x9370
leaq 0x20(%rsp), %rdi
callq 0x2f054
movq (%r15), %r13
movq 0x8(%r15), %r14
jmp 0x172a8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x174e8
testq %rbx, %rbx
je 0x174e8
testq %r15, %r15
je 0x174e8
cmpq %rbx, %rax
jbe 0x174e8
cmpq %rbx, %r15
je 0x174d6
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 0x92c0
imulq %rbx, %rbp
leaq (,%rbp,4), %rsi
addq %r13, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x92c0
movq 0x8(%r14), %rdx
imulq %rdx, %rbx
shlq $0x2, %rbx
addq 0x10(%r14), %rbx
shlq $0x2, %rdx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x92c0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1aff9(%rip), %rsi     # 0x324e8
movq %rsp, %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0x87, %edx
callq 0x2ee18
leaq 0x1b070(%rip), %rsi     # 0x32579
movq %r12, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
jmp 0x1744d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq (%rcx,%rdx), %rax
cmpq 0x8(%rdi), %rax
ja 0x17636
movq %r14, (%rsp)
movq (%r12), %rbx
movq %rbx, %rax
imulq %r13, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %r14d, %r14d
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %rbp
shlq $0x2, %r15
addq 0x10(%r12), %r15
movq %r13, 0x8(%rsp)
leaq (,%r13,4), %r12
movq %rbx, %r13
subq $0x1, %r13
jb 0x17610
leaq (%r14,%rbp), %rdi
leaq (%r15,%r14), %rsi
movq %r12, %rdx
callq 0x92c0
addq %r12, %r14
jmp 0x175f5
movq (%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
callq 0x17012
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rbx
leaq 0x1aea8(%rip), %rsi     # 0x324e8
leaq 0x10(%rsp), %r13
pushq $0x3
popq %rcx
movq %r13, %rdi
movl $0x9c, %edx
callq 0x2ee18
leaq 0x1af6d(%rip), %rsi     # 0x325c9
movq %r13, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %r13
jmp 0x175a9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17711
movq 0x8(%r15), %r12
leaq (%r12,%rbx), %rax
cmpq 0x8(%r14), %rax
ja 0x1774b
movq 0x10(%r15), %r15
shlq $0x2, %r12
xorl %r13d, %r13d
cmpq (%r14), %r13
je 0x17700
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 0x92c0
incq %r13
addq %r12, %r15
jmp 0x176d4
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1add0(%rip), %rsi     # 0x324e8
leaq 0x8(%rsp), %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0xab, %edx
callq 0x2ee18
leaq 0x1aebe(%rip), %rsi     # 0x325f2
movq %r12, %rdi
callq 0x9370
leaq 0x8(%rsp), %rdi
callq 0x2f054
jmp 0x176b7
leaq 0x1ad96(%rip), %rsi     # 0x324e8
leaq 0x8(%rsp), %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0xac, %edx
callq 0x2ee18
leaq 0x1aea6(%rip), %rsi     # 0x32614
movq %r12, %rdi
callq 0x9370
leaq 0x8(%rsp), %rdi
callq 0x2f054
movq 0x8(%r15), %r12
jmp 0x176c9
jmp 0x1778b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17a89
movq %rcx, %r12
movq %rdx, %r13
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x17a5f
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 0x17ab1
movq 0x10(%r15), %rdi
shlq $0x2, %rbx
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x91e0
movq 0x10(%r15), %rsi
addq $0x18, %r15
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x474c(%rip), %rax      # 0x1c216
movq %rax, 0x18(%r8)
leaq 0x4749(%rip), %rax      # 0x1c21e
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9f20
movq %rbx, %rdi
callq 0x16b18
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x27b12
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17bd4
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 0x1a874(%rip), %rsi     # 0x3244f
movq %rsp, %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0x88, %edx
callq 0x2ee18
leaq 0x1aa68(%rip), %rsi     # 0x3265d
movq %r12, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
jmp 0x17bbb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
je 0x17c65
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x1aa28(%rip), %rdi     # 0x32686
xorl %eax, %eax
callq 0x9050
leaq 0x18(%rsp), %r12
leaq 0x1aa2b(%rip), %r13     # 0x3269c
xorl %ebx, %ebx
xorl %esi, %esi
movl %ebp, 0xc(%rsp)
cmpq (%r15), %rsi
je 0x17d1d
testb %bpl, %bpl
movq %rsi, 0x10(%rsp)
je 0x17c9a
leaq 0x1a9ff(%rip), %rdi     # 0x32692
xorl %eax, %eax
callq 0x9050
xorl %ebp, %ebp
movq 0x8(%r15), %rax
cmpq %rax, %rbp
je 0x17ced
imulq %rbx, %rax
addq 0x10(%r15), %rax
movl (%rax,%rbp,4), %esi
movq %r12, %rdi
callq 0x17d3d
movq 0x18(%rsp), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x9050
movq %r12, %rdi
callq 0x9160
movq 0x8(%r15), %rax
decq %rax
cmpq %rax, %rbp
je 0x17ce8
movq (%r14), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x9050
incq %rbp
jmp 0x17c9c
movl 0xc(%rsp), %ebp
testb %bpl, %bpl
je 0x17d04
leaq 0x1a72e(%rip), %rdi     # 0x3242b
callq 0x9510
jmp 0x17d0c
pushq $0xa
popq %rdi
callq 0x9490
movq 0x10(%rsp), %rsi
incq %rsi
addq $0x4, %rbx
jmp 0x17c79
testb %bpl, %bpl
je 0x17d2e
leaq 0x1a702(%rip), %rdi     # 0x3242b
callq 0x9510
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb6e2
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movsd 0x14ad1(%rip), %xmm0    # 0x30010
movups %xmm0, 0x28(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %r15
movq %r15, 0x8(%rbx)
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(%rbx)
movq 0x10(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x92c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x17fd6
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movq 0x30(%rsp), %r13
callq 0x18fd4
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x16a8a(%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)
movsd (%r13), %xmm0
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x1ba76
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x191ea
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0xb6e2
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r14, %rax
imulq %r14, %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, %r15
leaq (,%r14,4), %rdx
imulq %r14, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x91e0
leaq 0x4(,%r14,4), %rax
movq %r14, %rcx
movq %r15, %rdx
subq $0x1, %rcx
jb 0x1bea7
movl $0x3f800000, (%rdx)     # imm = 0x3F800000
addq %rax, %rdx
jmp 0x1be96
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1823e
movq %rax, %r14
movq %rbx, %rdi
callq 0x17fd6
movq %r14, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c95d
movq 0x8(%rsi), %rcx
imulq (%rsi), %rcx
movq 0x8(%rdi), %rax
imulq (%rdi), %rax
cmpq %rcx, %rax
jne 0x1c961
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 0x574b(%rip), %r9       # 0x2207a
movq %r9, 0x18(%rsi)
leaq 0x574c(%rip), %r9       # 0x22086
movq %r9, 0x10(%rsi)
movq %rsi, (%rsp)
movq %rax, %rsi
movq %rcx, %r9
callq 0xb466
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movb 0xf(%rsp), %al
jmp 0x1c963
movb $0x1, %al
jmp 0x1c963
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ca0b
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 0x1c9c5
shlq $0x2, %r15
jmp 0x1c9f8
testq %rdi, %rdi
je 0x1c9d6
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 0x92c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x179e6
cmpl $0x0, (%r14)
je 0x1ca78
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5648(%rip), %rax      # 0x2209e
movq %rax, 0x18(%r8)
leaq 0x5645(%rip), %rax      # 0x220a6
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator+(abcdl::algebra::Matrix<int> const&) const
Matrix<T> Matrix<T>::operator + (const Matrix<T>& mat) const{
    
	if(get_size() == 0){
        return mat.clone();
    }

    CHECK(equal_shape(mat) 
          || (_cols == mat.cols() && mat.rows() == 1)
          || (_rows == mat.rows() && mat.cols() == 1));

    Matrix<T> new_mat = clone();

    if(equal_shape(mat) || (_cols == mat.cols() && mat.rows() == 1)){
        auto lambda = [](T* a, const T& b){*a += b;};
        _po.parallel_mul2mul_repeat(new_mat.data(), new_mat.get_size(), mat.data(), mat.get_size(), lambda);
    }else{
        for(size_t i = 0; i < _rows; i++){
            T value = mat.get_data(i, 0);
            for(size_t j = 0; j < _cols; j++){
                new_mat.set_data(get_data(i, j) + value, i, j);
            }
        }
    }
    return new_mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rdx
imulq %rcx, %rdx
testq %rdx, %rdx
je 0x1cba9
movq %rsi, %r14
movq (%r15), %rdx
movq 0x8(%r15), %rsi
cmpq %rdx, %rcx
sete %cl
cmpq %rsi, %rax
sete %al
cmpq $0x1, %rdx
sete %dl
orb %cl, %dl
andb %al, %dl
cmpq $0x1, %rsi
sete %al
andb %cl, %al
orb %dl, %al
jne 0x1cb2f
leaq 0x15fbd(%rip), %rsi     # 0x32ac0
leaq 0x10(%rsp), %r12
pushq $0x51
popq %rdx
pushq $0x3
popq %rcx
movq %r12, %rdi
callq 0x2ee18
leaq 0x15fc2(%rip), %rsi     # 0x32adf
movq %r12, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
movq %r14, %rsi
callq 0x179e6
movq (%r14), %rax
movq (%r15), %rdi
cmpq %rdi, %rax
setne %cl
cmpq $0x1, %rdi
setne %dl
testb %dl, %cl
jne 0x1cbc9
movq 0x8(%r14), %r8
cmpq 0x8(%r15), %r8
jne 0x1cbc9
addq $0x18, %r14
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
imulq (%rbx), %rdx
movq 0x10(%r15), %rcx
imulq %rdi, %r8
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r9
movaps %xmm0, (%r9)
leaq 0x5538(%rip), %rax      # 0x220be
movq %rax, 0x18(%r9)
leaq 0x5535(%rip), %rax      # 0x220c6
movq %rax, 0x10(%r9)
movq %r14, %rdi
callq 0xa910
leaq 0x10(%rsp), %rdi
callq 0x1a39e
jmp 0x1cbb4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x179e6
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
cmpq %rax, %r12
jae 0x1cbb4
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x16dec
movl (%rax), %r15d
xorl %ebp, %ebp
cmpq 0x8(%r14), %rbp
jae 0x1cc22
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x16dec
movl (%rax), %eax
addl %r15d, %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x16ef6
incq %rbp
jmp 0x1cbef
incq %r12
movq (%r14), %rax
jmp 0x1cbd6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2f054
jmp 0x1cc55
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1a39e
jmp 0x1cc4d
jmp 0x1cc4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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(get_size() == 0){
        set_data(mat);
        return *this;
    }

    CHECK(equal_shape(mat) 
          || (_cols == mat.cols() && mat.rows() == 1)
          || (_rows == mat.rows() && mat.cols() == 1));
    
    if(equal_shape(mat) || (_cols == mat.cols() && mat.rows() == 1)){
        auto lambda = [](T* a, const T& b){*a += b;};
        _po.parallel_mul2mul_repeat(_data, get_size(), mat.data(), mat.get_size(), lambda);
    }else{
        for(size_t i = 0; i < _rows; i++){
            T value = mat.get_data(i, 0);
            for(size_t j = 0; j < _cols; j++){
                set_data(get_data(i, j) + value, i, j);
            }
        }
    }
    return *this;
}

// 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 (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq %rcx, %rax
imulq %rdx, %rax
testq %rax, %rax
je 0x1cdbc
movq (%r14), %r8
movq 0x8(%r14), %rax
cmpq %r8, %rdx
sete %sil
cmpq %rax, %rcx
sete %dil
cmpq $0x1, %r8
sete %r9b
orb %sil, %r9b
andb %dil, %r9b
cmpq $0x1, %rax
sete %dil
andb %sil, %dil
orb %r9b, %dil
jne 0x1cd60
leaq 0x15d96(%rip), %rsi     # 0x32ac0
movq %rsp, %r15
pushq $0x72
popq %rdx
pushq $0x3
popq %rcx
movq %r15, %rdi
callq 0x2ee18
leaq 0x15d9d(%rip), %rsi     # 0x32adf
movq %r15, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq (%r14), %r8
movq 0x8(%r14), %rax
cmpq %r8, %rdx
setne %sil
cmpq $0x1, %r8
setne %dil
testb %dil, %sil
jne 0x1cddc
cmpq %rax, %rcx
jne 0x1cddc
leaq 0x18(%rbx), %rdi
movq 0x10(%rbx), %rsi
imulq %rax, %rdx
movq 0x10(%r14), %rcx
imulq %rax, %r8
xorps %xmm0, %xmm0
movq %rsp, %r9
movaps %xmm0, (%r9)
leaq 0x5360(%rip), %rax      # 0x220fe
movq %rax, 0x18(%r9)
leaq 0x535d(%rip), %rax      # 0x22106
movq %rax, 0x10(%r9)
callq 0xa910
movq %rsp, %rdi
callq 0x1a39e
jmp 0x1cdc7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ffe
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq %rsp, %r12
cmpq %rdx, %r15
jae 0x1cdc7
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x16dec
movl (%rax), %ebp
xorl %r13d, %r13d
cmpq 0x8(%rbx), %r13
jae 0x1ce2a
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x16dec
movl (%rax), %eax
addl %ebp, %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x16ef6
incq %r13
jmp 0x1cdf9
incq %r15
movq (%rbx), %rdx
jmp 0x1cde2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f054
jmp 0x1ce4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x179e6
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5294(%rip), %rax      # 0x2211e
movq %rax, 0x18(%r8)
leaq 0x5291(%rip), %rax      # 0x22126
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0