LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::OutputLayer::OutputLayer(unsigned long, unsigned long, abcdl::framework::ActivateFunc*, abcdl::framework::Cost*, float const&, float const&)
OutputLayer(const size_t input_dim,
                const size_t output_dim,
                abcdl::framework::ActivateFunc* activate_func,
                abcdl::framework::Cost* cost,
                const real& mean_value = 0.0f,
                const real& stddev = 0.5f) : Layer(input_dim, output_dim, abcdl::framework::OUTPUT){
        _cost           = cost;
        _activate_func  = activate_func;

        this->_weight.reset(_input_dim, _output_dim, mean_value, stddev);
        this->_bias.reset(1, _output_dim, mean_value, stddev);
    }

// Assembly:
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl $0x4, %ecx
callq 0x16c90
movq 0x8(%rsp), %rdi
leaq 0xb4ef7(%rip), %rax     # 0xcacf8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x178, %rdi            # imm = 0x178
movq %rdi, 0x10(%rsp)
callq 0x33a40
jmp 0x15e1b
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x170(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x168(%rax)
movq %rax, %rdi
addq $0x30, %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq 0x38(%rsp), %rcx
movq 0x70(%rsp), %r8
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq %rsp, %rax
leaq 0x24(%rsp), %r9
movq %r9, (%rax)
leaq 0x28(%rsp), %r9
callq 0x3ab00
jmp 0x15e78
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x68, %rdi
movq 0x10(%rax), %rdx
movq 0x38(%rsp), %rcx
movq 0x70(%rsp), %r8
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq %rsp, %rax
leaq 0x1c(%rsp), %rsi
movq %rsi, (%rax)
movl $0x1, %esi
leaq 0x20(%rsp), %r9
callq 0x3ab00
jmp 0x15ebe
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x15eeb
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x33e80
movq 0x8(%rsp), %rdi
callq 0x16f00
movq 0x30(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/include/fnn/FNN.h
// Function: abcdl::fnn::FNN::~FNN()
~FNN(){
        for(auto& layer : _layers){
            delete layer;
			layer = nullptr;
        }
        _layers.clear();

        if(_loss != nullptr){
            delete _loss;
            _loss = nullptr;
        }

    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x30, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x178a0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x178d0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1a820
testb $0x1, %al
jne 0x168af
jmp 0x168f4
leaq 0x30(%rsp), %rdi
callq 0x1a860
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x168dc
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
leaq 0x30(%rsp), %rdi
callq 0x1a870
jmp 0x1689a
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x1a890
movq 0x18(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1693a
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1692d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0x16aa0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x16800
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x9260
addq $0x48, %rsp
retq
nopl (%rax)
// File: btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<float>::Matrix(abcdl::algebra::Matrix<float> 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0xd590
movq 0x18(%rsp), %rdi
callq 0x1a390
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x1a3a0
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x19380
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
shlq $0x2, %rdx
imulq 0x8(%rax), %rdx
callq 0x9370
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: btbujiangjun[P]abcdl/include/utils/MnistHelper.h
// Function: abcdl::utils::MnistHelper<float>::read_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, abcdl::algebra::Matrix<float>*, int)
bool MnistHelper<T>::read_label(const std::string& label_file,
                                abcdl::algebra::Matrix<T>* out_mat,
                                const int limit){
    size_t count = 0;
    auto label_buffer = read_mnist_file(label_file, 0x801, &count);
    if(!label_buffer || count == 0){
        return false;
    }

    if( limit > 0 && limit < (int)count){
        count = limit;
    }

    //read label data
    auto label_data_buffer = reinterpret_cast<unsigned char*>(label_buffer.get() + 8);

    T* labels = new T[count];
    for(size_t i = 0; i < count; i++){
        labels[i] = static_cast<T>(*label_data_buffer++);
    }

    out_mat->set_shallow_data(labels, count, 1);

    return true;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movq 0x68(%rsp), %rsi
movq $0x0, 0x48(%rsp)
movq 0x60(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movl $0x801, %ecx            # imm = 0x801
leaq 0x48(%rsp), %r8
callq 0x18db0
leaq 0x40(%rsp), %rdi
callq 0x192c0
testb $0x1, %al
jne 0x1a4ae
jmp 0x1a4b6
cmpq $0x0, 0x48(%rsp)
jne 0x1a4c8
movb $0x0, 0x77(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x1a5b7
cmpl $0x0, 0x54(%rsp)
jle 0x1a4e6
movl 0x54(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl %ecx, %eax
jge 0x1a4e6
movslq 0x54(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19350
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x9030
movq %rax, 0x8(%rsp)
jmp 0x1a520
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x1a58f
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1a533
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19470
jmp 0x1a5cc
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl $0x1, %ecx
callq 0x34360
jmp 0x1a5aa
movb $0x1, 0x77(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19470
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/include/utils/MnistHelper.h
// Function: abcdl::utils::MnistHelper<float>::read_vec_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, abcdl::algebra::Matrix<float>*, int, unsigned long)
bool MnistHelper<T>::read_vec_label(const std::string& label_file,
                                    abcdl::algebra::Matrix<T>* out_mat,
                                    const int limit,
                                    const size_t vec_size){
    size_t count = 0;
    auto label_buffer = read_mnist_file(label_file, 0x801, &count);
    if(!label_buffer || count == 0){
        return false;
    }

    if( limit > 0 && limit < (int)count){
        count = limit;
    }

    //read label data
    auto label_data_buffer = reinterpret_cast<unsigned char*>(label_buffer.get() + 8);

    T* labels = new T[count * vec_size];
    memset(labels, 0, sizeof(T) * count * vec_size);

    for(size_t i = 0; i < count; i++){
        auto label = static_cast<size_t>(*label_data_buffer++);
        labels[i * vec_size + label] = 1;
    }

    out_mat->set_shallow_data(labels, count, vec_size);

    return true;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movq 0x78(%rsp), %rsi
movq $0x0, 0x50(%rsp)
movq 0x70(%rsp), %rdx
leaq 0x48(%rsp), %rdi
movl $0x801, %ecx            # imm = 0x801
leaq 0x50(%rsp), %r8
callq 0x18db0
leaq 0x48(%rsp), %rdi
callq 0x192c0
testb $0x1, %al
jne 0x26df6
jmp 0x26dfe
cmpq $0x0, 0x50(%rsp)
jne 0x26e13
movb $0x0, 0x87(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0x26f3e
cmpl $0x0, 0x64(%rsp)
jle 0x26e31
movl 0x64(%rsp), %eax
movq 0x50(%rsp), %rcx
cmpl %ecx, %eax
jge 0x26e31
movslq 0x64(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x19350
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
imulq %rcx, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x9030
movq %rax, 0x8(%rsp)
jmp 0x26e74
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x58(%rsp), %rdx
xorl %esi, %esi
callq 0x9210
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x26f13
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rsp)
movzbl (%rax), %eax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
imulq 0x58(%rsp), %rcx
addq 0x10(%rsp), %rcx
movss 0x67128(%rip), %xmm0    # 0x8e00c
movss %xmm0, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x26ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x19470
jmp 0x26f59
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x34360
jmp 0x26f2e
movb $0x1, 0x87(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x19470
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/fnn/Layer.cpp
// Function: abcdl::fnn::OutputLayer::backward(abcdl::fnn::Layer*, abcdl::fnn::Layer*)
void OutputLayer::backward(Layer* pre_layer, Layer* next_layer){
    /*
     * L layer(last layer) Error
     * Error δL = cost->delta
     */
    _cost->delta(this->_delta_bias, this->_activate_data, this->_y);
    /*
     * Derivative(Cw) = a_in * δ_out
     * a_in = a_L-1, δ_out = delta
     */
    this->_delta_weight   = _helper.dot(pre_layer->get_activate_data().Ts(), this->_delta_bias);

    this->_batch_weight   += this->_delta_weight;
    this->_batch_bias     += this->_delta_bias;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x170(%rcx), %rdi
movq %rcx, %rsi
addq $0xf0, %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, %rdx
addq $0xa0, %rdx
addq $0x178, %rcx            # imm = 0x178
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rdi
callq 0x27c10
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35830
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x6a250
jmp 0x275c2
movq (%rsp), %rdi
addq $0xc8, %rdi
leaq 0x58(%rsp), %rsi
callq 0x429a0
jmp 0x275d9
leaq 0x58(%rsp), %rdi
callq 0x33e80
leaq 0x30(%rsp), %rdi
callq 0x33e80
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0xc8, %rsi
addq $0x118, %rdi            # imm = 0x118
callq 0x432b0
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0xf0, %rsi
addq $0x140, %rdi            # imm = 0x140
callq 0x432b0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x27651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x33e80
leaq 0x30(%rsp), %rdi
callq 0x33e80
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/include/utils/Shuffler.h
// Function: abcdl::utils::Shuffler::shuffle()
void Shuffler::shuffle(){

    std::random_device rd;
    size_t random_idx, value;

    for(size_t i = _size - 1; i != 0 ; i--){
        random_idx = rd() % i;
        value =  _shuffler_idx[random_idx];

        _shuffler_idx[random_idx] = _shuffler_idx[i];
        _shuffler_idx[i] = value;
    }

}

// Assembly:
subq $0x13d8, %rsp           # imm = 0x13D8
movq %rdi, 0x13d0(%rsp)
movq 0x13d0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2b940
movq 0x18(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x27f68
leaq 0x48(%rsp), %rdi
callq 0x2b9e0
movl %eax, 0x14(%rsp)
jmp 0x27eb3
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x30(%rsp)
movq %rdx, 0x40(%rsp)
addq $0x8, %rdi
movq 0x40(%rsp), %rsi
callq 0x2b9f0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x38(%rsp)
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x2b9f0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movq 0x40(%rsp), %rsi
callq 0x2b9f0
movq (%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x2b9f0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x27e97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2ba10
jmp 0x27f7a
leaq 0x48(%rsp), %rdi
callq 0x2ba10
addq $0x13d8, %rsp           # imm = 0x13D8
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/src/fnn/FNN.cpp
// Function: abcdl::fnn::FNN::auc(std::vector<std::pair<float, float>, std::allocator<std::pair<float, float>>>&)
double FNN::auc(std::vector<std::pair<real,real>>& auc_vec){
    if(auc_vec.size() == 0){
        return 0;
    }
    std::sort(auc_vec.begin(), auc_vec.end(), [](const std::pair<real, real> a, const std::pair<real, real> b){return a.second < b.second;});
    size_t m = 0;
    double rank = 0;
    for(size_t i = 0; i < auc_vec.size(); i++){
        //printf("i:%zu, label:%lf,value:%lf\n", i, auc_vec[i].first, auc_vec[i].second);
        if(auc_vec[i].first > 0){
            m += 1;
            rank += (i+1);
            //printf("m:%zu, rank:%lf\n", m, rank);
        }
    }
    //printf("M:%zu, N:%zu, rank:%lf\n", m, auc_vec.size() - m , rank);
    return (rank - m * (m + 1) / 2) / (m * (auc_vec.size() - m));
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2c160
cmpq $0x0, %rax
jne 0x28bec
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x28d4e
movq 0x50(%rsp), %rdi
callq 0x2c180
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2c1b0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29ae0
movq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2c160
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x28ccd
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2c1e0
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x28cb8
movq 0x30(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
incq %rax
movq %rax, %xmm0
movaps 0x672ff(%rip), %xmm1    # 0x8ff90
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x67303(%rip), %xmm1    # 0x8ffa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x28cba
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x28c34
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, %rcx
incq %rcx
imulq %rcx, %rax
shrq %rax
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2c160
movsd 0x8(%rsp), %xmm0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rdx
subq %rdx, %rcx
imulq %rcx, %rax
movq %rax, %xmm1
movaps 0x67267(%rip), %xmm2    # 0x8ff90
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6726b(%rip), %xmm2    # 0x8ffa0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x1a3a0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17270
movq (%rax), %rdi
callq 0x17310
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2997e
jmp 0x299da
leaq 0x6662b(%rip), %rsi     # 0x8ffb0
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x86, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x10(%rsp), %rdi
leaq 0x66899(%rip), %rsi     # 0x90243
callq 0x2c200
jmp 0x299b1
leaq 0x48(%rsp), %rdi
callq 0x89c20
jmp 0x299da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x89c20
jmp 0x29ac7
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x17250
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x29a90
cmpq $0x0, 0x28(%rsp)
jne 0x29a31
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x28(%rsp), %rsi
callq 0x17270
movq (%rax), %rdi
movq 0x1d0(%rsp), %rsi
callq 0x26f70
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x28(%rsp), %rsi
callq 0x17270
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x17270
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x28(%rsp)
jbe 0x29a7b
jmp 0x29a7b
jmp 0x29a7d
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x299f6
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x30(%rsp), %rsi
subq $0x1, %rsi
callq 0x17270
movq (%rax), %rdi
callq 0x27c10
movq %rax, %rsi
movq 0x1d8(%rsp), %rdi
callq 0x429a0
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x40(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2c290
movq $0x1, 0xa8(%rsp)
movq 0x40(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x30, %rdi
callq 0x17250
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
je 0x2a59f
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
movq 0xa8(%rsp), %rsi
callq 0x17270
movq (%rax), %rdi
callq 0x27c50
movq %rax, 0x30(%rsp)
jmp 0x2a4fe
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x2d040
jmp 0x2a522
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
movq 0xa8(%rsp), %rsi
callq 0x17270
movq (%rax), %rdi
callq 0x2d070
movq %rax, 0x28(%rsp)
jmp 0x2a547
movq 0x28(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2d040
jmp 0x2a56b
jmp 0x2a56d
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x2a4ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x2a698
movq 0x40(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x2d760
jmp 0x2a5c1
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9710
movq 0x18(%rsp), %rdx
leaq 0x65caf(%rip), %rsi     # 0x90298
leaq 0x50(%rsp), %rdi
callq 0x9580
jmp 0x2a5f5
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rcx
xorl %r8d, %r8d
callq 0x2d080
movb %al, 0xf(%rsp)
jmp 0x2a617
leaq 0x50(%rsp), %rdi
callq 0x9260
leaq 0x4f(%rsp), %rdi
callq 0x9470
leaq 0x70(%rsp), %rdi
callq 0x2cfe0
leaq 0xb0(%rsp), %rdi
callq 0x2cfe0
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x2a684
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x9260
leaq 0x4f(%rsp), %rdi
callq 0x9470
leaq 0x70(%rsp), %rdi
callq 0x2cfe0
leaq 0xb0(%rsp), %rdi
callq 0x2cfe0
movq 0x98(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movss %xmm0, 0x94(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x94(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x98(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x20(%rsp)
testq %rax, %rax
movss %xmm0, 0x24(%rsp)
js 0x2bbad
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x10(%rsp), %rsi
movss 0x1c(%rsp), %xmm0
movss 0x24(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x90(%rsp)
addq $0x118, %rsi            # imm = 0x118
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x90(%rsp), %rdx
callq 0x44250
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rdi
callq 0x43e80
jmp 0x2bbfe
leaq 0x68(%rsp), %rdi
callq 0x33e80
movq 0x10(%rsp), %rsi
addq $0x140, %rsi            # imm = 0x140
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x90(%rsp), %rdx
callq 0x44250
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x68, %rdi
callq 0x43e80
jmp 0x2bc3e
leaq 0x30(%rsp), %rdi
callq 0x33e80
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x35570
movq 0x10(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x35570
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x33e80
jmp 0x2bcc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x33e80
movq 0x60(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2ddf0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2ddf0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x2dd7c
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2dd45
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2dd43
movq 0x10(%rsp), %rdi
callq 0x9540
jmp 0x2dd45
movq 0x28(%rsp), %rdi
callq 0x2ddf0
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
callq 0x1a390
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x1a3a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x19380
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2ddf0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
shlq $0x2, %rdx
callq 0x9370
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1e8(%rsp)
movq %rsi, 0x1e0(%rsp)
movq %rdx, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x30f80
movq %rax, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0x30fb0
movq %rax, 0x1c0(%rsp)
leaq 0x1c8(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x30fe0
testb $0x1, %al
jne 0x30cdf
jmp 0x30e19
leaq 0x1c8(%rsp), %rdi
callq 0x31020
movq %rax, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rax
movq (%rax), %rdi
callq 0x1a390
movq %rax, 0x1a8(%rsp)
movq 0x1b8(%rsp), %rax
movq (%rax), %rdi
callq 0x1a3a0
movq %rax, 0x1b0(%rsp)
movq 0x9b2a5(%rip), %rdi     # 0xcbfd0
movq 0x9b256(%rip), %rsi     # 0xcbf88
callq 0x31030
testb $0x1, %al
jne 0x30d3d
jmp 0x30d4a
movb $0x69, 0x1a0(%rsp)
jmp 0x30df2
movq 0x9b27f(%rip), %rsi     # 0xcbfd0
movq %rsi, %rdi
callq 0x31030
testb $0x1, %al
jne 0x30d5f
jmp 0x30d6c
movb $0x66, 0x1a0(%rsp)
jmp 0x30df0
movq 0x9b25d(%rip), %rdi     # 0xcbfd0
movq 0x9b276(%rip), %rsi     # 0xcbff0
callq 0x31030
testb $0x1, %al
jne 0x30d85
jmp 0x30d8f
movb $0x64, 0x1a0(%rsp)
jmp 0x30dee
leaq 0x5f617(%rip), %rsi     # 0x903ad
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl $0xde, %edx
movl $0x3, %ecx
callq 0x89860
movq (%rsp), %rdi
leaq 0x5f654(%rip), %rsi     # 0x9040d
callq 0x310b0
jmp 0x30dc0
leaq 0x18(%rsp), %rdi
callq 0x89c20
movb $0x0, 0x1f7(%rsp)
jmp 0x30e21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x89c20
jmp 0x30e32
jmp 0x30df0
jmp 0x30df2
movq 0x1d8(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x2f740
leaq 0x1c8(%rsp), %rdi
callq 0x310e0
jmp 0x30cc1
movb $0x1, 0x1f7(%rsp)
movb 0x1f7(%rsp), %al
andb $0x1, %al
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x10(%rsp), %rdi
callq 0x9700
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0xa640
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rax, (%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq (%rax), %rdx
shlq $0x2, %rdx
imulq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x9210
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x18, %rdi
callq 0xa640
movq 0x28(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, (%rcx)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x78(%rsp), %rax
cmpl $0x0, (%rax)
je 0x31723
movq 0x78(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x3174c
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rdi
movq 0x78(%rsp), %rax
movl (%rax), %eax
movq (%rcx), %rdx
shlq $0x2, %rdx
imulq 0x8(%rcx), %rdx
movzbl %al, %esi
callq 0x9210
jmp 0x317d2
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
callq 0x317f0
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x67(%rsp), %rsi
callq 0x31810
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xad50
jmp 0x317ac
leaq 0x40(%rsp), %rdi
callq 0x318a0
jmp 0x317d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x318a0
jmp 0x317da
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0xa640
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rax), %rdx
shlq $0x2, %rdx
imulq 0x8(%rax), %rdx
callq 0x9370
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
je 0x31ae2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x31ad5
movq (%rsp), %rdi
callq 0x9540
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movq 0x20(%rsp), %rcx
imulq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x31f3e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31f06
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x31f04
movq 0x8(%rsp), %rdi
callq 0x9540
jmp 0x31f06
movq 0x20(%rsp), %rax
imulq 0x18(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x18(%rsp), %rdx
callq 0x9370
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rax)
je 0x32029
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x32027
movq 0x8(%rsp), %rdi
callq 0x9540
jmp 0x32029
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x1c0(%rsp), %rax
addq 0x1b8(%rsp), %rax
cmpq (%rcx), %rax
setbe %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32142
jmp 0x3219e
leaq 0x5e3ef(%rip), %rsi     # 0x90538
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x5a, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x8(%rsp), %rdi
leaq 0x5e3e5(%rip), %rsi     # 0x90553
callq 0xc340
jmp 0x32175
leaq 0x30(%rsp), %rdi
callq 0x89c20
jmp 0x3219e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x89c20
jmp 0x3223c
movq 0x10(%rsp), %rcx
movq 0x1b8(%rsp), %rax
imulq 0x8(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
movq 0x1c0(%rsp), %rcx
imulq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0x1b8(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x8(%rax), %rdx
callq 0x9370
movq 0x10(%rsp), %rax
movq 0x1c8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x1b8(%rsp), %rdx
movq 0x8(%rax), %rcx
callq 0x31fe0
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1d0(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x1c8(%rsp), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, 0x1f(%rsp)
jae 0x327f8
movq 0x10(%rsp), %rdx
movq 0x1c0(%rsp), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, 0x1f(%rsp)
jae 0x327f8
xorl %eax, %eax
cmpq $0x1, 0x1c8(%rsp)
movb %al, 0x1f(%rsp)
jb 0x327f8
cmpq $0x1, 0x1c0(%rsp)
setae %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32804
jmp 0x32860
leaq 0x5dd2d(%rip), %rsi     # 0x90538
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x87, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x8(%rsp), %rdi
leaq 0x5dd99(%rip), %rsi     # 0x905c9
callq 0x32960
jmp 0x32837
leaq 0x38(%rsp), %rdi
callq 0x89c20
jmp 0x32860
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x89c20
jmp 0x32951
movq 0x1c8(%rsp), %rax
cmpq 0x1c0(%rsp), %rax
jne 0x32877
jmp 0x32949
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rsi
movq 0x1c8(%rsp), %rcx
imulq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
shlq $0x2, %rdx
leaq 0x20(%rsp), %rdi
callq 0x9370
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x1c8(%rsp), %rcx
imulq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movq 0x1c0(%rsp), %rcx
imulq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
shlq $0x2, %rdx
callq 0x9370
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x1c0(%rsp), %rcx
imulq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rdx
shlq $0x2, %rdx
leaq 0x20(%rsp), %rsi
callq 0x9370
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x30(%rsp), %rdi
callq 0x9700
nopl (%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x1c0(%rsp), %rax
addq 0x1b8(%rsp), %rax
cmpq 0x8(%rcx), %rax
setbe %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32a83
jmp 0x32add
leaq 0x5daae(%rip), %rsi     # 0x90538
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x9c, %edx
movl $0x3, %ecx
callq 0x89860
movq (%rsp), %rdi
leaq 0x5db6c(%rip), %rsi     # 0x90619
callq 0xc340
jmp 0x32ab4
leaq 0x30(%rsp), %rdi
callq 0x89c20
jmp 0x32add
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x89c20
jmp 0x32bb7
movq 0x8(%rsp), %rax
movq (%rax), %rax
imulq 0x1b8(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
je 0x32b8d
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rcx
imulq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
imulq 0x1b8(%rsp), %rax
addq 0x1c0(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x1b8(%rsp), %rdx
shlq $0x2, %rdx
callq 0x9370
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x32b1d
movq 0x8(%rsp), %rax
movq 0x1c8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rax), %rdx
movq 0x1b8(%rsp), %rcx
callq 0x31fe0
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x378, %rsp            # imm = 0x378
movq %rdi, 0x370(%rsp)
movq %rsi, 0x368(%rsp)
movq %rdx, 0x360(%rsp)
movq 0x370(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x360(%rsp), %rdi
callq 0x31a10
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32c4c
jmp 0x32cb7
leaq 0x5d8e5(%rip), %rsi     # 0x90538
leaq 0x1d8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0xab, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x18(%rsp), %rdi
leaq 0x5d9c7(%rip), %rsi     # 0x90642
callq 0x310b0
jmp 0x32c82
leaq 0x1d8(%rsp), %rdi
callq 0x89c20
jmp 0x32cb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d0(%rsp)
movl %eax, 0x1cc(%rsp)
leaq 0x1d8(%rsp), %rdi
callq 0x89c20
jmp 0x32ded
movq 0x368(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x360(%rsp), %rdi
callq 0x31a20
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq %rdx, %rax
cmpq 0x8(%rcx), %rax
setbe %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32cf0
jmp 0x32d52
leaq 0x5d841(%rip), %rsi     # 0x90538
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xac, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x8(%rsp), %rdi
leaq 0x5d948(%rip), %rsi     # 0x90664
callq 0x32450
jmp 0x32d23
leaq 0x40(%rsp), %rdi
callq 0x89c20
jmp 0x32d52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d0(%rsp)
movl %eax, 0x1cc(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x89c20
jmp 0x32ded
movq 0x360(%rsp), %rdi
callq 0x31a30
movq %rax, 0x38(%rsp)
movq 0x360(%rsp), %rdi
callq 0x31a20
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq (%rcx), %rax
je 0x32de5
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rdi
movq 0x28(%rsp), %rax
imulq 0x8(%rcx), %rax
addq 0x368(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rax
imulq 0x30(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x30(%rsp), %rdx
shlq $0x2, %rdx
callq 0x9370
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x32d7f
addq $0x378, %rsp            # imm = 0x378
retq
movq 0x1d0(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x331c4
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x32e00
jmp 0x331d3
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x32480
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x80(%rsp), %rax
imulq 0x78(%rsp), %rax
movq %rax, 0x70(%rsp)
callq 0x317f0
cmpq 0x70(%rsp), %rax
je 0x33342
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x332fc
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x332fa
movq 0x28(%rsp), %rdi
callq 0x9540
jmp 0x332fc
movq 0x70(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x88(%rsp), %rax
cmpl $0x0, (%rax)
je 0x3335c
movq 0x88(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x33385
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x88(%rsp), %rax
movl (%rax), %eax
movq 0x70(%rsp), %rdx
shlq $0x2, %rdx
movzbl %al, %esi
callq 0x9210
jmp 0x3340e
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, (%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x6f(%rsp), %rsi
callq 0x33420
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xad50
jmp 0x333e8
leaq 0x48(%rsp), %rdi
callq 0x318a0
jmp 0x3340e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x318a0
jmp 0x33416
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x9700
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x334f0
movq 0x10(%rsp), %rdi
movb $0x0, 0x37(%rsp)
callq 0x315c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x69d20
jmp 0x33558
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x3358a
jmp 0x33580
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x31a40
jmp 0x33593
movq 0x10(%rsp), %rdi
callq 0x31a40
movq (%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopl (%rax)