LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq 0x1c0(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x1b8(%rsp), %rax
imulq 0x1b0(%rsp), %rax
movq (%rdx), %rcx
imulq 0x8(%rdx), %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x335f3
jmp 0x3364c
leaq 0x5ce35(%rip), %rsi     # 0x9042f
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x88, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x8(%rsp), %rdi
leaq 0x5d08e(%rip), %rsi     # 0x906ad
callq 0xc340
jmp 0x33626
leaq 0x28(%rsp), %rdi
callq 0x89c20
jmp 0x3364c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x89c20
jmp 0x33670
movq 0x10(%rsp), %rax
movq 0x1b8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x1b0(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x20(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x57(%rsp)
je 0x33711
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x5cfcc(%rip), %rdi     # 0x906d6
movb $0x0, %al
callq 0x9060
movq $0x0, 0x48(%rsp)
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
cmpq (%rcx), %rax
je 0x33856
testb $0x1, 0x57(%rsp)
je 0x33747
movq 0x48(%rsp), %rsi
leaq 0x5cfa2(%rip), %rdi     # 0x906e2
movb $0x0, %al
callq 0x9060
movq $0x0, 0x40(%rsp)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
cmpq 0x8(%rcx), %rax
je 0x3381c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
movq 0x48(%rsp), %rcx
imulq %rdx, %rcx
movq 0x40(%rsp), %rdx
addq %rdx, %rcx
movl (%rax,%rcx,4), %esi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x33880
movq (%rsp), %rdi
callq 0x9170
movq %rax, %rsi
leaq 0x5cf46(%rip), %rdi     # 0x906ec
xorl %eax, %eax
callq 0x9060
jmp 0x337af
leaq 0x20(%rsp), %rdi
callq 0x9260
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x33807
movq 0x58(%rsp), %rdi
callq 0x9170
movq %rax, %rsi
leaq 0x5cf08(%rip), %rdi     # 0x906ec
movb $0x0, %al
callq 0x9060
jmp 0x33807
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x9260
jmp 0x33870
jmp 0x33809
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x33750
testb $0x1, 0x57(%rsp)
je 0x33833
leaq 0x5a89c(%rip), %rdi     # 0x8e0c6
movb $0x0, %al
callq 0x9060
jmp 0x33841
leaq 0x5cea6(%rip), %rdi     # 0x906e0
movb $0x0, %al
callq 0x9060
jmp 0x33843
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x3371a
testb $0x1, 0x57(%rsp)
je 0x3386b
leaq 0x5a862(%rip), %rdi     # 0x8e0c6
movb $0x0, %al
callq 0x9060
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x33a40
movq 0x18(%rsp), %rax
movl $0x0, 0x28(%rax)
movl $0x3f800000, 0x2c(%rax) # imm = 0x3F800000
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movq 0x38(%rsp), %rdi
callq 0x1a390
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
callq 0x1a3a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rdi
callq 0x2ddf0
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x9030
movq %rax, 0x20(%rsp)
jmp 0x3a4e5
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x19380
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2ddf0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
shlq $0x2, %rdx
callq 0x9370
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x33e80
movq 0x30(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::RandomMatrix<float>::RandomMatrix(unsigned long, unsigned long, float const&, float const&, float const&, float 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:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x33a80
movq (%rsp), %rdi
movl $0x0, 0x28(%rdi)
movl $0x3f800000, 0x2c(%rdi) # imm = 0x3F800000
movl $0x0, 0x30(%rdi)
movl $0x0, 0x34(%rdi)
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x28(%rdi)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x2c(%rdi)
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x30(%rdi)
movq 0x50(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x34(%rdi)
callq 0x3a630
jmp 0x3a5fe
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x33e80
movq 0x10(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::RandomMatrix<float>::reset(unsigned long, unsigned long, float const&, float const&, float const&, float const&)
void RandomMatrix<T>::reset(size_t rows,
                            size_t cols,
                            const T& mean_value,
                            const T& stddev,
                            const T& min,
                            const T& max){
    if(rows * cols != this->_rows * this->_cols){
        if(this->_data != nullptr){
            delete[] this->_data;
        }
        this->_data = new T[rows * cols];
    }

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

    reset();
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x38(%rsp), %rax
imulq 0x30(%rsp), %rax
movq (%rdx), %rcx
imulq 0x8(%rdx), %rcx
cmpq %rcx, %rax
je 0x3abad
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3ab75
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3ab73
movq 0x8(%rsp), %rdi
callq 0x9540
jmp 0x3ab75
movq 0x38(%rsp), %rax
imulq 0x30(%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), %rdi
movq 0x38(%rsp), %rax
movq %rax, (%rdi)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rdi)
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x28(%rdi)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x2c(%rdi)
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x30(%rdi)
movq 0x50(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x34(%rdi)
callq 0x3a630
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33a40
movq 0x38(%rsp), %rax
imulq %rax, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x9030
movq %rax, 0x10(%rsp)
jmp 0x3b548
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x38(%rsp), %rdx
xorl %esi, %esi
callq 0x9210
movss 0x52a97(%rip), %xmm0    # 0x8e00c
movss %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x3b5da
movss 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
imulq 0x38(%rsp), %rcx
addq 0x18(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3b584
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x33e80
jmp 0x3b5f8
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x34360
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq 0x80(%rsp), %rax
jne 0x3eecb
movb $0x1, 0x97(%rsp)
jmp 0x3efb7
movq 0x80(%rsp), %rdi
callq 0x317f0
movq 0x38(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x317f0
cmpq 0x78(%rsp), %rax
je 0x3eefb
movb $0x0, 0x97(%rsp)
jmp 0x3efb7
movq 0x38(%rsp), %rdi
movb $0x1, 0x77(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0x317f0
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x76(%rsp), %rsi
callq 0x3efe0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x77(%rsp), %rsi
callq 0xd0a0
jmp 0x3ef84
leaq 0x50(%rsp), %rdi
callq 0x3f070
movb 0x77(%rsp), %al
andb $0x1, %al
movb %al, 0x97(%rsp)
jmp 0x3efb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3f070
jmp 0x3efc8
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq 0x28(%rsp), %rax
je 0x3f1a5
movq 0x28(%rsp), %rdi
callq 0x317f0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x317f0
cmpq 0x20(%rsp), %rax
je 0x3f151
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3f11f
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3f11d
movq 0x10(%rsp), %rdi
callq 0x9540
jmp 0x3f11f
movq 0x20(%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 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
callq 0x31a10
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x31a20
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31a30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
shlq $0x2, %rdx
callq 0x9370
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movb $0x0, 0x7f(%rsp)
callq 0x331e0
movq 0x80(%rsp), %rax
cmpl $0x0, (%rax)
je 0x3f2a1
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
callq 0x31a30
movq 0x30(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x7e(%rsp), %rsi
callq 0x3f2d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xad50
jmp 0x3f271
leaq 0x58(%rsp), %rdi
callq 0x318a0
jmp 0x3f2a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x30(%rsp), %rdi
callq 0x31a40
jmp 0x3f2c4
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x3f2b7
movq 0x30(%rsp), %rdi
callq 0x31a40
movq 0x38(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x9700
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movb $0x0, 0x7e(%rsp)
callq 0x331e0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
addq $0x18, %rax
movq %rax, 0x20(%rsp)
callq 0x31a30
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x317f0
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x3ff00
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0xad50
jmp 0x3fea0
leaq 0x58(%rsp), %rdi
callq 0x318a0
movb $0x1, 0x7e(%rsp)
testb $0x1, 0x7e(%rsp)
jne 0x3fee6
jmp 0x3fedc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x18(%rsp), %rdi
callq 0x31a40
jmp 0x3fef3
movq 0x18(%rsp), %rdi
callq 0x31a40
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x9700
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/(int const&) const
Matrix<T> Matrix<T>::operator / (const T& value) const{
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    auto new_mat = clone();
    _po.parallel_mul2one(new_mat.data(), new_mat.get_size(), value, lambda);
    return new_mat;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq %rdx, 0x200(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x200(%rsp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x414ff
jmp 0x4155b
leaq 0x4fa4a(%rip), %rsi     # 0x90f50
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0xf4, %edx
movl $0x3, %ecx
callq 0x89860
movq 0x28(%rsp), %rdi
leaq 0x4fabb(%rip), %rsi     # 0x90fe6
callq 0x41640
jmp 0x41532
leaq 0x78(%rsp), %rdi
callq 0x89c20
jmp 0x4155b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x89c20
jmp 0x4162d
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movb $0x0, 0x6a(%rsp)
callq 0x331e0
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rdi
addq $0x18, %rax
movq %rax, (%rsp)
callq 0x31a30
movq 0x30(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x317f0
movq %rax, 0x10(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x6b(%rsp), %rsi
callq 0x41670
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xad50
jmp 0x415da
leaq 0x48(%rsp), %rdi
callq 0x318a0
movb $0x1, 0x6a(%rsp)
testb $0x1, 0x6a(%rsp)
jne 0x41620
jmp 0x41616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x318a0
movq 0x30(%rsp), %rdi
callq 0x31a40
jmp 0x4162d
movq 0x30(%rsp), %rdi
callq 0x31a40
movq 0x38(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x70(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/=(int const&)
Matrix<T>& Matrix<T>::operator /= (const T& value){
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    _po.parallel_mul2one(_data, get_size(), value, lambda);
	return *this;
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x1f8(%rsp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x41c7a
jmp 0x41cd6
leaq 0x4f2cf(%rip), %rsi     # 0x90f50
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x113, %edx            # imm = 0x113
movl $0x3, %ecx
callq 0x89860
movq 0x30(%rsp), %rdi
leaq 0x4f340(%rip), %rsi     # 0x90fe6
callq 0x41640
jmp 0x41cad
leaq 0x70(%rsp), %rdi
callq 0x89c20
jmp 0x41cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x89c20
jmp 0x41d6a
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x63(%rsp), %rsi
callq 0x41d80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xad50
jmp 0x41d3b
leaq 0x40(%rsp), %rdi
callq 0x318a0
movq 0x38(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x318a0
movq 0x68(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<int>() const
Matrix<T>::operator Matrix<int>() const{
    Matrix<int> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<int>(get_data(i)));
	}
    return mat;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x57(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x31600
movq 0x20(%rsp), %rdi
callq 0x317f0
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x4231d
movq 0x20(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rsi
callq 0x31af0
movq %rax, 0x8(%rsp)
jmp 0x422d8
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rdx
leaq 0x3c(%rsp), %rsi
callq 0x31cc0
jmp 0x422f1
jmp 0x422f3
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x422ae
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x31a40
jmp 0x4233d
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x42333
movq 0x10(%rsp), %rdi
callq 0x31a40
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<unsigned long>::operator abcdl::algebra::Matrix<float>() const
Matrix<T>::operator Matrix<float>() const{
    Matrix<float> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<float>(get_data(i)));
	}
    return mat;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x67(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x33a80
movq 0x30(%rsp), %rdi
callq 0x38230
movq %rax, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x4d12b
movq 0x50(%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, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x4d05c
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x4c(%rsp)
movq 0x50(%rsp), %rsi
callq 0x38530
movq %rax, 0x10(%rsp)
jmp 0x4d07e
movq 0x10(%rsp), %rax
movq (%rax), %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, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x4d0bf
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rdx
movq %rdx, %rcx
sarq $0x3f, %rcx
movss 0x4338f(%rip), %xmm1    # 0x90470
subss %xmm1, %xmm0
cvttss2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rdx
leaq 0x4c(%rsp), %rsi
callq 0x34030
jmp 0x4d0fc
jmp 0x4d0fe
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x4d00e
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x33e80
jmp 0x4d14b
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x4d141
movq 0x20(%rsp), %rdi
callq 0x33e80
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<double>() const
Matrix<T>::operator Matrix<double>() const{
    Matrix<double> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<double>(get_data(i)));
	}
    return mat;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x57(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x35cc0
movq 0x20(%rsp), %rdi
callq 0x317f0
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x42598
movq 0x20(%rsp), %rdi
movaps 0x4da76(%rip), %xmm1    # 0x8ff90
movq 0x40(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4da74(%rip), %xmm1    # 0x8ffa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rsi
callq 0x31af0
movq %rax, 0x8(%rsp)
jmp 0x42552
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
leaq 0x38(%rsp), %rsi
callq 0x363a0
jmp 0x4256c
jmp 0x4256e
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x424fe
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x36120
jmp 0x425b8
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x425ae
movq 0x10(%rsp), %rdi
callq 0x36120
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<unsigned long>() const
Matrix<T>::operator Matrix<size_t>() const{
    Matrix<size_t> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<size_t>(get_data(i)));
	}
    return mat;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x47(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x38040
movq 0x18(%rsp), %rdi
callq 0x317f0
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x42683
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x31af0
movq %rax, (%rsp)
jmp 0x4263f
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movslq (%rax), %rdx
leaq 0x30(%rsp), %rsi
callq 0x38700
jmp 0x42657
jmp 0x42659
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x4261e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x38480
jmp 0x426a3
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x42699
movq 0x8(%rsp), %rdi
callq 0x38480
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x9700
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::max() const
T Matrix<T>::max() const{
	if(get_size() == 0){
		return 0;
	}
	T max = _data[0];
	auto lambda = [](T* a, const T& b){if(b > *a){*a = b;}};
	_po.parallel_reduce_mul2one(&max, _data, get_size(), lambda);
	return max;   
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x317f0
cmpq $0x0, %rax
jne 0x5b68b
movl $0x0, 0x74(%rsp)
jmp 0x5b71b
movq 0x28(%rsp), %rdi
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x63(%rsp), %rsi
callq 0x5b730
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x64(%rsp), %rsi
callq 0xc440
jmp 0x5b6ed
leaq 0x40(%rsp), %rdi
callq 0x318a0
movl 0x64(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0x5b71b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x318a0
jmp 0x5b724
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::argmax() const
size_t Matrix<T>::argmax() const{
	if(get_size() == 0){
		return 0;
	}
	T max = _data[0];
    size_t max_idx = 0;
	auto lambda = [](T* a, const T& b, size_t* max_idx, const size_t idx){if(b > *a){*a = b; *max_idx = idx;}};
	_po.parallel_reduce_mul2one(&max, &max_idx, _data, get_size(), lambda);
	return max_idx;   
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x317f0
cmpq $0x0, %rax
jne 0x5b7f2
movq $0x0, 0x80(%rsp)
jmp 0x5b895
movq 0x28(%rsp), %rdi
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, 0x74(%rsp)
movq $0x0, 0x68(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x67(%rsp), %rsi
callq 0x5b8b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
leaq 0x74(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xc810
jmp 0x5b862
leaq 0x40(%rsp), %rdi
callq 0x5b940
movq 0x68(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x5b895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b940
jmp 0x5b8a5
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::min() const
T Matrix<T>::min() const{
	if(get_size() == 0){
		return 0;
	}
	T min = _data[0];
	auto lambda = [](T* a, const T& b){if(b < *a){*a = b;}};
	_po.parallel_reduce_mul2one(&min, _data, get_size(), lambda);
	return min;   
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x317f0
cmpq $0x0, %rax
jne 0x5bedb
movl $0x0, 0x74(%rsp)
jmp 0x5bf6b
movq 0x28(%rsp), %rdi
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x63(%rsp), %rsi
callq 0x5bf80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x64(%rsp), %rsi
callq 0xc440
jmp 0x5bf3d
leaq 0x40(%rsp), %rdi
callq 0x318a0
movl 0x64(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0x5bf6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x318a0
jmp 0x5bf74
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::argmin() const
size_t Matrix<T>::argmin() const{
	if(get_size() == 0){
		return 0;
	}
	T min = _data[0];
    size_t min_idx = 0;
	auto lambda = [](T* a, const T& b, size_t* min_idx, const size_t idx){if(b < *a){*a = b; *min_idx = idx;}};
	_po.parallel_reduce_mul2one(&min, &min_idx, _data, get_size(), lambda);
	return min_idx;   
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x317f0
cmpq $0x0, %rax
jne 0x5c042
movq $0x0, 0x80(%rsp)
jmp 0x5c0e5
movq 0x28(%rsp), %rdi
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, 0x74(%rsp)
movq $0x0, 0x68(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x67(%rsp), %rsi
callq 0x5c100
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
leaq 0x74(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xc810
jmp 0x5c0b2
leaq 0x40(%rsp), %rdi
callq 0x5b940
movq 0x68(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x5c0e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b940
jmp 0x5c0f5
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::sum() const
T Matrix<T>::sum() const{
	T sum = 0;
	auto lambda = [](T* a, const T& b){if(b != 0){ *a += b;} };
	_po.parallel_reduce_mul2one(&sum, _data, get_size(), lambda);
	return sum;   
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movl $0x0, 0x5c(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x5b(%rsp), %rsi
callq 0x5c230
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x5c(%rsp), %rsi
callq 0xc440
jmp 0x5c1f9
leaq 0x38(%rsp), %rdi
callq 0x318a0
movl 0x5c(%rsp), %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x318a0
movq 0x30(%rsp), %rdi
callq 0x9700
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::outer(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::outer(Matrix<T>& mat,
							const Matrix<T>& mat_a,
							const Matrix<T>& mat_b){
    size_t size_a = mat_a.get_size();
    size_t size_b = mat_b.get_size();
    T* data_a = mat_a.data();
    T* data_b = mat_b.data();
    T* data   = new T[size_a * size_b];
    auto lambda = [](T* a, const T& b, const T& c){*a = b * c;};
    _po.parallel_mul2mul_cross(data, data_a, size_a, data_b, size_b, lambda);
    mat.set_shallow_data(data, size_a, size_b);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x317f0
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x317f0
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x31a30
movq %rax, 0x90(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x31a30
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rcx
imulq %rcx, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x9030
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x66ec0
movq 0x10(%rsp), %r10
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %r9
movq %rsp, %rax
movq %r10, (%rax)
callq 0xbf80
jmp 0x66e64
leaq 0x58(%rsp), %rdi
callq 0x66f50
movq 0xb8(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0x98(%rsp), %rcx
callq 0x31fe0
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x66f50
movq 0x50(%rsp), %rdi
callq 0x9700
nopl (%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::pow(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, int const&)
void MatrixHelper<T>::pow(Matrix<T>& mat,
						  const Matrix<T>& mat_a,
						  const T& exponent){
    auto lambda = [](T* a, const T& b, const T& c){*a = std::pow(b, c);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), exponent, lambda);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %rdi
callq 0x317f0
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rdi
callq 0x317f0
movq %rax, %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
je 0x67011
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x80(%rsp)
movq 0x90(%rsp), %rdi
callq 0x31a10
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rdi
callq 0x31a20
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
leaq 0x80(%rsp), %rsi
callq 0x33280
movq 0x98(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rdi
callq 0x31a30
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rdi
callq 0x317f0
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x87(%rsp), %rsi
callq 0x670d0
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0xb3d0
jmp 0x67090
leaq 0x60(%rsp), %rdi
callq 0x66f50
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x66f50
movq 0x58(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nop
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::log(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::log(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::log(b);};
    if(mat.get_size() == mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x317f0
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
jne 0x67203
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a10
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a20
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
leaq 0x78(%rsp), %rsi
callq 0x33280
movq 0x88(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x672b0
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb090
jmp 0x6726d
leaq 0x58(%rsp), %rdi
callq 0x318a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x50(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sigmoid(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sigmoid(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = 1 / (1 + std::exp(-(std::min((T)SIGMOID_MAX, std::max(b, (T)SIGMOID_MIN)))));};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x317f0
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
je 0x67b63
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a10
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a20
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
leaq 0x78(%rsp), %rsi
callq 0x33280
movq 0x88(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x67c10
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb090
jmp 0x67bcd
leaq 0x58(%rsp), %rdi
callq 0x318a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x50(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::softmax(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::softmax(Matrix<T>& mat, const Matrix<T>& mat_a){
    T max = mat_a.max();
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0x5b660
movl %eax, 0x6c(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x70(%rsp), %rax
je 0x67f09
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a30
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a10
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a20
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
callq 0x31ea0
movq 0x78(%rsp), %rdi
callq 0x31a30
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
callq 0x317f0
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x6b(%rsp), %rsi
callq 0x67fb0
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r8
leaq 0x6c(%rsp), %rcx
callq 0xad50
jmp 0x67f59
leaq 0x48(%rsp), %rdi
callq 0x318a0
movq 0x78(%rsp), %rdi
callq 0x5c190
movl %eax, 0x38(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x41c40
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x318a0
movq 0x40(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::relu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::relu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b < 0) {*a = 0;} };
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
je 0x68493
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a10
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a20
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
callq 0x31ea0
movq 0x88(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x68540
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb090
jmp 0x684fd
leaq 0x58(%rsp), %rdi
callq 0x318a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x50(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::relu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::relu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b > 0) {*a = 1;} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x70(%rsp), %rax
je 0x68644
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a10
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
leaq 0x68(%rsp), %rsi
callq 0x33280
movq 0x78(%rsp), %rdi
callq 0x31a30
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x317f0
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x6f(%rsp), %rsi
callq 0x686e0
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xb090
jmp 0x686a3
leaq 0x48(%rsp), %rdi
callq 0x318a0
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x318a0
movq 0x40(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::leaky_relu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::leaky_relu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b < 0) {*a = (T)(0.01 * b);} };
    if(&mat != &mat_a){
        mat.set_data(mat_a.data(), mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
je 0x68803
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a10
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a20
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
callq 0x31ea0
movq 0x88(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31a30
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x317f0
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x688b0
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb090
jmp 0x6886d
leaq 0x58(%rsp), %rdi
callq 0x318a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x318a0
movq 0x50(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::leaky_relu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::leaky_relu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0){*a = (T)1;} else{*a = (T)0.01;} };
    if(&mat != &mat_a){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x70(%rsp), %rax
je 0x689b4
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a10
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
leaq 0x68(%rsp), %rsi
callq 0x33280
movq 0x78(%rsp), %rdi
callq 0x31a30
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x31a30
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x317f0
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x6f(%rsp), %rsi
callq 0x68a50
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xb090
jmp 0x68a13
leaq 0x48(%rsp), %rdi
callq 0x318a0
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x318a0
movq 0x40(%rsp), %rdi
callq 0x9700
nopw (%rax,%rax)