LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator-(abcdl::algebra::Matrix<int> const&) const
Matrix<T> Matrix<T>::operator - (const Matrix<T>& mat) const{
    CHECK(equal_shape(mat) 
          || (_cols == mat.cols() && mat.rows() == 1)
          || (_rows == mat.rows() && mat.cols() == 1));
    
    auto new_mat = clone();
    if(equal_shape(mat) || (_cols == mat.cols() && mat.rows() == 1)){
        auto lambda = [](T* a, const T& b){*a -= b;};
        _po.parallel_mul2mul_repeat(new_mat.data(), new_mat.get_size(), mat.data(), mat.get_size(), lambda);
    }else{
        for(size_t i = 0; i < _rows; i++){
            T value = mat.get_data(i, 0);
            for(size_t j = 0; j < _cols; j++){
                new_mat.set_data(get_data(i, j) - value, i, j);
            }
        }
    }
    return new_mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
cmpq %rax, (%rsi)
sete %dl
cmpq %rcx, 0x8(%rsi)
sete %sil
cmpq $0x1, %rax
sete %al
orb %dl, %al
andb %sil, %al
cmpq $0x1, %rcx
sete %cl
andb %dl, %cl
orb %al, %cl
jne 0x1cf51
leaq 0x15b9d(%rip), %rsi     # 0x32ac0
leaq 0x10(%rsp), %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0x8e, %edx
callq 0x2ee18
leaq 0x15ba0(%rip), %rsi     # 0x32adf
movq %r12, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
movq %r14, %rsi
callq 0x179e6
movq (%r14), %rax
movq (%r15), %rdi
cmpq %rdi, %rax
setne %cl
cmpq $0x1, %rdi
setne %dl
testb %dl, %cl
jne 0x1cfde
movq 0x8(%r14), %r8
cmpq 0x8(%r15), %r8
jne 0x1cfde
addq $0x18, %r14
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
imulq (%rbx), %rdx
movq 0x10(%r15), %rcx
imulq %rdi, %r8
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r9
movaps %xmm0, (%r9)
leaq 0x5196(%rip), %rax      # 0x2213e
movq %rax, 0x18(%r9)
leaq 0x5193(%rip), %rax      # 0x22146
movq %rax, 0x10(%r9)
movq %r14, %rdi
callq 0xa910
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
cmpq %rax, %r12
jae 0x1cfc9
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x16dec
movl (%rax), %r15d
xorl %ebp, %ebp
cmpq 0x8(%r14), %rbp
jae 0x1d037
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x16dec
movl (%rax), %eax
subl %r15d, %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x16ef6
incq %rbp
jmp 0x1d004
incq %r12
movq (%r14), %rax
jmp 0x1cfeb
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2f054
jmp 0x1d06a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1a39e
jmp 0x1d062
jmp 0x1d05f
movq %rax, %r14
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/(int const&) const
Matrix<T> Matrix<T>::operator / (const T& value) const{
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    auto new_mat = clone();
    _po.parallel_mul2one(new_mat.data(), new_mat.get_size(), value, lambda);
    return new_mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, (%rdx)
je 0x1d6c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x179e6
addq $0x18, %r15
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x4b9e(%rip), %rax      # 0x2222e
movq %rax, 0x18(%r8)
leaq 0x4ba1(%rip), %rax      # 0x2223c
movq %rax, 0x10(%r8)
movq %r15, %rdi
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x153f5(%rip), %rsi     # 0x32ac0
movq %rsp, %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0xf4, %edx
callq 0x2ee18
leaq 0x15471(%rip), %rsi     # 0x32b56
movq %r12, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
jmp 0x1d664
movq %rax, %r14
movq %rsp, %rdi
callq 0x2f054
jmp 0x1d71a
movq %rax, %r14
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator/=(int const&)
Matrix<T>& Matrix<T>::operator /= (const T& value){
	CHECK(value != 0);
    auto lambda = [](T* a, const T& b){*a /= b;};
    _po.parallel_mul2one(_data, get_size(), value, lambda);
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x1d96f
leaq 0x18(%rbx), %rdi
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x49b6(%rip), %rax      # 0x222f6
movq %rax, 0x18(%r8)
leaq 0x49b9(%rip), %rax      # 0x22304
movq %rax, 0x10(%r8)
movq %r14, %rcx
callq 0xa1be
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1514a(%rip), %rsi     # 0x32ac0
movq %rsp, %r15
pushq $0x3
popq %rcx
movq %r15, %rdi
movl $0x113, %edx            # imm = 0x113
callq 0x2ee18
leaq 0x151c6(%rip), %rsi     # 0x32b56
movq %r15, %rdi
callq 0x9370
movq %rsp, %rdi
callq 0x2f054
jmp 0x1d91f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f054
jmp 0x1d9bd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<int>() const
Matrix<T>::operator Matrix<int>() const{
    Matrix<int> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<int>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x16b32
movq 0x8(%r14), %r13
imulq (%r14), %r13
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
cmpq %r15, %r13
je 0x1dbcb
movl %r15d, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x16d6a
movslq (%rax), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16e74
incq %r15
jmp 0x1dba3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x16d30
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<unsigned long>::operator abcdl::algebra::Matrix<float>() const
Matrix<T>::operator Matrix<float>() const{
    Matrix<float> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<float>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x17dc6
movq 0x8(%r14), %r13
imulq (%r14), %r13
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
cmpq %r15, %r13
je 0x21eeb
testq %r15, %r15
js 0x21e6c
cvtsi2ss %r15, %xmm0
jmp 0x21e84
movq %r15, %rax
shrq %rax
movl %r15d, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a4c2
movq (%rax), %rax
testq %rax, %rax
js 0x21ea4
cvtsi2ss %rax, %xmm0
jmp 0x21eb9
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x105cb(%rip), %xmm0    # 0x32498
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18098
incq %r15
jmp 0x21e57
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17fd6
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<unsigned long>::operator abcdl::algebra::Matrix<double>() const
Matrix<T>::operator Matrix<double>() const{
    Matrix<double> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<double>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x18fd4
movq 0x8(%r14), %r13
imulq (%r14), %r13
xorl %r15d, %r15d
movq 0x1005e(%rip), %xmm1    # 0x31fa0
movapd 0x10066(%rip), %xmm2    # 0x31fb0
leaq 0x8(%rsp), %r12
cmpq %r15, %r13
je 0x21fe3
movq %r15, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a4c2
movsd (%rax), %xmm0
unpcklps 0x10013(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1001b(%rip), %xmm0    # 0x31fb0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x10b03(%rip), %xmm1    # 0x32ab8
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1932e
incq %r15
movq 0xffca(%rip), %xmm1     # 0x31fa0
movapd 0xffd2(%rip), %xmm2     # 0x31fb0
jmp 0x21f4f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x191ea
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixOperator.cpp
// Function: abcdl::algebra::Matrix<int>::operator abcdl::algebra::Matrix<unsigned long>() const
Matrix<T>::operator Matrix<size_t>() const{
    Matrix<size_t> mat(_rows, _cols);
	size_t size = get_size();
	for(size_t i = 0; i < size; i++){
		mat.set_data(i, static_cast<size_t>(get_data(i)));
	}
    return mat;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x1a26c
movq 0x8(%r14), %r12
imulq (%r14), %r12
xorl %esi, %esi
movq %rsp, %r15
movq %rsi, (%rsp)
cmpq %r12, %rsi
jae 0x1dd9b
movq %r14, %rdi
callq 0x16d6a
movslq (%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a5cc
movq (%rsp), %rsi
incq %rsi
jmp 0x1dd73
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a488
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::argmax(abcdl::algebra::Axis_type) const
Matrix<size_t> Matrix<T>::argmax(Axis_type axis_type) const{
    size_t size = (axis_type == Axis_type::ROW)? _rows : _cols;
   	size_t end_idx = (axis_type == Axis_type::ROW) ? _cols : _rows;
    size_t* idx_data = new size_t[size];
    for(size_t i = 0; i != size; i++){
        T max_value = 0;
        size_t max_idx = 0;
        for(size_t j = 0; j != end_idx; j++){
            T value = (axis_type == Axis_type::ROW) ? _data[i * _cols + j] : _data[j * _cols + i];
            if( j == 0 || value > max_value){
                max_value = value;
                max_idx = j;
            }
        }
        idx_data[i] = max_idx;
    }

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

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

    return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, 0x20(%rsp)
testl %edx, %edx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq %r12, %r15
cmoveq %r14, %r15
movq %r14, 0x18(%rsp)
cmoveq %r12, %r14
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %ebx, %ebx
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x8(%rsp)
movq 0x10(%r13), %rax
movq %r12, 0x10(%rsp)
leaq (,%r12,4), %rcx
movq %rax, %rdx
cmpq %r15, %rbx
je 0x23397
xorl %esi, %esi
movq %rax, %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rsi, %r14
je 0x23382
testl %ebp, %ebp
movq %rdi, %r11
cmoveq %r8, %r11
movl (%r11), %r11d
testq %rsi, %rsi
sete %r13b
cmpl %r10d, %r11d
setg %r12b
orb %r13b, %r12b
movq %rsi, %r13
jne 0x23370
movq %r9, %r13
movl %r10d, %r11d
incq %rsi
addq $0x4, %r8
addq %rcx, %rdi
movq %r13, %r9
movl %r11d, %r10d
jmp 0x23343
movq 0x8(%rsp), %rsi
movq %r9, (%rsi,%rbx,8)
incq %rbx
addq %rcx, %rdx
addq $0x4, %rax
jmp 0x23330
testl %ebp, %ebp
pushq $0x1
popq %rax
movq 0x18(%rsp), %r14
cmovneq %rax, %r14
movq 0x10(%rsp), %r15
cmoveq %rax, %r15
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a252
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1a76c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a488
movq %r14, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::argmax(unsigned long, abcdl::algebra::Axis_type) const
size_t Matrix<T>::argmax(const size_t id, const Axis_type axis_type) const{
    bool is_row = (axis_type == abcdl::algebra::Axis_type::ROW);
	if(is_row){
        CHECK(id < _rows);
    }else{
        CHECK(id < _cols);
    }

    size_t max_idx 	= 0;
	T max 			= is_row ? get_data(id, 0) : get_data(0, id);
	size_t size 	= is_row ? _cols : _rows;
	
	for(size_t i = 0; i != size; i++){
		T value = is_row ? get_data(id, i) : get_data(i, id);
		if(value > max){
			max = value;
			max_idx = i;
		}
	}
	return max_idx;   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0xc(%rsp)
testl %edx, %edx
je 0x2342e
cmpq %r14, 0x8(%r15)
jbe 0x2349d
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x16dec
jmp 0x23447
cmpq %r14, (%r15)
jbe 0x234d7
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x16dec
pushq $0x8
popq %rbx
movl (%rax), %ebp
movq (%r15,%rbx), %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x23488
cmpl $0x0, 0xc(%rsp)
je 0x2346a
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
jmp 0x23473
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x16dec
movl (%rax), %eax
cmpl %ebp, %eax
cmovgq %r13, %r12
cmovgl %eax, %ebp
incq %r13
jmp 0x23453
movq %r12, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x102c4(%rip), %rsi     # 0x33768
leaq 0x10(%rsp), %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0xc1, %edx
callq 0x2ee18
leaq 0x102df(%rip), %rsi     # 0x3379f
movq %r12, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
jmp 0x2341d
leaq 0x1028a(%rip), %rsi     # 0x33768
leaq 0x10(%rsp), %r12
pushq $0x3
popq %rcx
movq %r12, %rdi
movl $0xbf, %edx
callq 0x2ee18
leaq 0x1028c(%rip), %rsi     # 0x33786
movq %r12, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
jmp 0x23437
jmp 0x23513
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixAlgebra.cpp
// Function: abcdl::algebra::Matrix<int>::sum() const
T Matrix<T>::sum() const{
	T sum = 0;
	auto lambda = [](T* a, const T& b){if(b != 0){ *a += b;} };
	_po.parallel_reduce_mul2one(&sum, _data, get_size(), lambda);
	return sum;   
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
leaq 0x18(%rdi), %rax
movq 0x8(%rdi), %rcx
imulq (%rdi), %rcx
movq 0x10(%rdi), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x2b9e(%rip), %rdi      # 0x261ec
movq %rdi, 0x18(%r8)
leaq 0x2b9f(%rip), %rdi      # 0x261f8
movq %rdi, 0x10(%r8)
movq %rax, %rdi
callq 0xadb6
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movl 0xc(%rsp), %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::outer(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::outer(Matrix<T>& mat,
							const Matrix<T>& mat_a,
							const Matrix<T>& mat_b){
    size_t size_a = mat_a.get_size();
    size_t size_b = mat_b.get_size();
    T* data_a = mat_a.data();
    T* data_b = mat_b.data();
    T* data   = new T[size_a * size_b];
    auto lambda = [](T* a, const T& b, const T& c){*a = b * c;};
    _po.parallel_mul2mul_cross(data, data_a, size_a, data_b, size_b, lambda);
    mat.set_shallow_data(data, size_a, size_b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movq 0x8(%rdx), %rbx
movq 0x10(%rdx), %r13
imulq (%rdx), %rbx
movq 0x8(%rcx), %r15
movq 0x10(%rcx), %rbp
imulq (%rcx), %r15
movq %r15, %rax
imulq %rbx, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x60bb(%rip), %rcx      # 0x2c95e
movq %rcx, 0x18(%rax)
leaq 0x60bc(%rip), %rcx      # 0x2c96a
movq %rcx, 0x10(%rax)
movq %rax, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0xab48
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x17012
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::pow(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&, int const&)
void MatrixHelper<T>::pow(Matrix<T>& mat,
						  const Matrix<T>& mat_a,
						  const T& exponent){
    auto lambda = [](T* a, const T& b, const T& c){*a = std::pow(b, c);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), exponent, lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rsi
imulq (%r12), %rsi
movq (%rdx), %rdx
movq 0x8(%r15), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x2695a
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r12, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r15), %rcx
imulq (%r15), %rcx
movq 0x10(%r12), %rsi
movq 0x10(%r15), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r9
movaps %xmm0, (%r9)
leaq 0x600e(%rip), %rax      # 0x2c982
movq %rax, 0x18(%r9)
leaq 0x601d(%rip), %rax      # 0x2c99c
movq %rax, 0x10(%r9)
movq %r14, %rdi
movq %rbx, %r8
callq 0xa52c
movq %rsp, %rdi
callq 0x1a39e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::log(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::log(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::log(b);};
    if(mat.get_size() == mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
jne 0x269fc
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5f9f(%rip), %rax      # 0x2c9b4
movq %rax, 0x18(%r8)
leaq 0x5f9a(%rip), %rax      # 0x2c9ba
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::exp(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::exp(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::exp(std::min(b, (T)EXP_MAX));};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26a98
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5f45(%rip), %rax      # 0x2c9f6
movq %rax, 0x18(%r8)
leaq 0x5f40(%rip), %rax      # 0x2c9fc
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sqrt(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sqrt(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::sqrt(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26b34
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5ef5(%rip), %rax      # 0x2ca42
movq %rax, 0x18(%r8)
leaq 0x5f10(%rip), %rax      # 0x2ca68
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sin(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sin(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::sin(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26bd0
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5e97(%rip), %rax      # 0x2ca80
movq %rax, 0x18(%r8)
leaq 0x5ea2(%rip), %rax      # 0x2ca96
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::cos(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::cos(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = std::cos(b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26c6c
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5e29(%rip), %rax      # 0x2caae
movq %rax, 0x18(%r8)
leaq 0x5e34(%rip), %rax      # 0x2cac4
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26d08
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5dbb(%rip), %rax      # 0x2cadc
movq %rax, 0x18(%r8)
leaq 0x5db6(%rip), %rax      # 0x2cae2
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::sigmoid_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::sigmoid_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = b * (1 - b);};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26da4
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5d7d(%rip), %rax      # 0x2cb3a
movq %rax, 0x18(%r8)
leaq 0x5d82(%rip), %rax      # 0x2cb4a
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x231cc
movl %eax, 0xc(%rsp)
cmpq %r15, %rbx
je 0x26e30
movq 0x10(%r15), %rsi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rbx, %rdi
callq 0x16f7e
movq 0x8(%rbx), %rdx
imulq (%rbx), %rdx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x5d13(%rip), %rax      # 0x2cb62
movq %rax, 0x18(%r8)
leaq 0x5d0e(%rip), %rax      # 0x2cb68
movq %rax, 0x10(%r8)
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
callq 0xa1be
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x2361e
movl %eax, (%r14)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d908
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::tanh(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::tanh(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ *a = 2.0 /(1.0 + std::exp(std::min((T)EXP_MAX, -2 * b))) - 1.0;};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26ef6
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5c97(%rip), %rax      # 0x2cba6
movq %rax, 0x18(%r8)
leaq 0x5c92(%rip), %rax      # 0x2cbac
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::tanh_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::tanh_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ T tanh = std::exp(std::min((T)EXP_MAX, -2 * b)); *a = 1 - tanh * tanh;};
    if(mat.get_size() != mat_a.get_size()){
        mat.reset(0, mat_a.rows(), mat_a.cols());
    }
    _po.parallel_mul2one_copy(mat.data(), mat_a.data(), mat_a.get_size(), lambda);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
imulq (%r15), %rsi
movq (%rdx), %rdx
movq 0x8(%r14), %rax
movq %rax, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rsi
je 0x26f92
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
movq %rax, %rcx
callq 0x17a24
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r15), %rsi
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5c5d(%rip), %rax      # 0x2cc08
movq %rax, 0x18(%r8)
leaq 0x5c58(%rip), %rax      # 0x2cc0e
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x27012
movq 0x10(%r14), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x16f7e
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5c23(%rip), %rax      # 0x2cc56
movq %rax, 0x18(%r8)
leaq 0x5c26(%rip), %rax      # 0x2cc64
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x2709c
movq %rsp, %rsi
andl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x17a24
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5bbf(%rip), %rax      # 0x2cc7c
movq %rax, 0x18(%r8)
leaq 0x5bc4(%rip), %rax      # 0x2cc8c
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x27124
movq 0x10(%r14), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x16f7e
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5b5f(%rip), %rax      # 0x2cca4
movq %rax, 0x18(%r8)
leaq 0x5b72(%rip), %rax      # 0x2ccc2
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x271ae
movq %rsp, %rsi
andl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x17a24
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5b0b(%rip), %rax      # 0x2ccda
movq %rax, 0x18(%r8)
leaq 0x5b0e(%rip), %rax      # 0x2cce8
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::elu(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::elu(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0) {*a = b;} else{*a = std::exp(std::min((T)EXP_MAX, b)) - 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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x27238
movq %rsp, %rsi
andl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x17a24
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5aa7(%rip), %rax      # 0x2cd00
movq %rax, 0x18(%r8)
leaq 0x5aa2(%rip), %rax      # 0x2cd06
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/algebra/MatrixHelper.cpp
// Function: abcdl::algebra::MatrixHelper<int>::elu_derivative(abcdl::algebra::Matrix<int>&, abcdl::algebra::Matrix<int> const&)
void MatrixHelper<T>::elu_derivative(Matrix<T>& mat, const Matrix<T>& mat_a){
    auto lambda = [](T* a, const T& b){ if(b >= 0) {*a = 1;} else{*a = std::exp(std::min((T)EXP_MAX, b));} };
    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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x272c2
movq %rsp, %rsi
andl $0x0, (%rsi)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x17a24
movq 0x10(%r15), %rsi
movq 0x8(%r14), %rcx
imulq (%r14), %rcx
movq 0x10(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x5a63(%rip), %rax      # 0x2cd46
movq %rax, 0x18(%r8)
leaq 0x5a5e(%rip), %rax      # 0x2cd4c
movq %rax, 0x10(%r8)
movq %rbx, %rdi
callq 0xa374
movq %rsp, %rdi
callq 0x1a39e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a39e
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::LogMessage::generate_log_message()
void LogMessage::generate_log_message(){
    time_t timep;
    time(&timep);
    char time_data[64];
    strftime(time_data, sizeof(time_data), "%Y-%m-%d %H:%M:%S", localtime(&timep));
    if(!g_log_inited){
        fprintf(stderr, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data,  _name, _line, str().c_str());
    }else{
        for(auto& fd : g_log_fds[this->_severity]){
            dprintf(fd, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data, _name, _line, str().c_str());
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbp
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x9340
movq %r14, %rdi
callq 0x9260
leaq 0x6b53(%rip), %rdx      # 0x35a5b
leaq 0x50(%rsp), %rdi
pushq $0x40
popq %rsi
movq %rax, %rcx
callq 0x92b0
cmpb $0x0, 0x204f1(%rip)     # 0x4f410
je 0x2efc6
movslq 0x7c(%rbp), %rax
movq 0x204b0(%rip), %rcx     # 0x4f3e0
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r14
movq 0x8(%rcx,%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x8(%rbp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rbx
cmpq 0x20(%rsp), %r14
je 0x2f02d
movl (%r14), %eax
movl %eax, 0x14(%rsp)
movslq 0x7c(%rbp), %rax
movq 0x20453(%rip), %rcx     # 0x4f3c0
shlq $0x5, %rax
movq (%rcx,%rax), %r12
movq 0x70(%rbp), %r13
movq %rbp, %r15
movl 0x78(%rbp), %ebp
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x9540
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
leaq 0x6acd(%rip), %rsi      # 0x35a6d
movq %r12, %rdx
leaq 0x50(%rsp), %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x91f0
movq %rbx, %rdi
callq 0x9160
addq $0x4, %r14
movq %r15, %rbp
jmp 0x2ef50
movq 0x1fff3(%rip), %rax     # 0x4efc0
movq (%rax), %r14
movslq 0x7c(%rbp), %rax
movq 0x203e5(%rip), %rcx     # 0x4f3c0
shlq $0x5, %rax
movq %rbp, %rsi
movq (%rcx,%rax), %r15
movq 0x70(%rbp), %r12
movl 0x78(%rbp), %ebp
addq $0x8, %rsi
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x9540
movq (%r13), %rax
movq %rax, (%rsp)
leaq 0x6a60(%rip), %rsi      # 0x35a6d
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x94c0
movq %r13, %rdi
callq 0x9160
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::load(unsigned int)
uint32_t MIPS::BUS::load(uint32_t addr) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF0004) {
    if (inputBuffer.empty()) {
      std::string input;
      getline(std::cin, input);
      input += "\n";
      for (int i = 0; i < input.length(); i++)
        inputBuffer.push_back(input[i]);
    }
    char in = inputBuffer.front();
    inputBuffer.pop_front();
    return in;
  } else {
    return ram.load(addr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cmpl $0xffff0004, %esi       # imm = 0xFFFF0004
jne 0x2655
leaq 0x8(%r14), %rbx
movq 0x18(%r14), %rax
cmpq %rax, 0x38(%r14)
jne 0x2675
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x89bd(%rip), %rdi      # 0xafd8
leaq 0x8(%rsp), %rsi
callq 0x2050
leaq 0x49d8(%rip), %rsi      # 0x7004
leaq 0x8(%rsp), %rdi
callq 0x23c0
xorl %r15d, %r15d
cmpq %r15, 0x10(%rsp)
jbe 0x2667
movq 0x8(%rsp), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x277c
incq %r15
jmp 0x2639
movq (%r14), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6110
leaq 0x8(%rsp), %rdi
callq 0x23e8
movq 0x18(%r14), %rax
movsbl (%rax), %ebp
movq %rbx, %rdi
callq 0x279a
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x268f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x23e8
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::store(unsigned int, unsigned int)
void MIPS::BUS::store(uint32_t addr, uint32_t data) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF000C) {
    outputBuffer = std::string(1, (char)data);
  } else {
    ram.store(addr, data);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xffff000c, %esi       # imm = 0xFFFF000C
jne 0x26f1
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %dl, %edx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x2250
addq $0x58, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x23e8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x5ff2
// File: /workspace/github_cpp_makefile_star2_O2/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::CPU(MIPS::BUS&)
MIPS::CPU::CPU(MIPS::BUS & bus) : MEM(bus)
{
  // Internal flags and tracking vars
  isExecuting = true;
  cycles = 0;
  stage = S_FETCH;

  // Setup registers
  PC = 0x00000000;
  hi = lo = 0;
  RA = RB = RZ = RM = RY = 0;
  for (int i = 0; i < 32; i++) R[i] = 0;

  R[31] = 0x8123456C; // Exit address
  R[30] = 0x01000000; // Start of Stack
}

// Assembly:
movq %rsi, 0x98(%rdi)
movb $0x1, (%rdi)
andl $0x0, 0x4(%rdi)
andq $0x0, 0x8c(%rdi)
andl $0x0, 0x94(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rdi)
andq $0x0, 0xb0(%rdi)
xorl %eax, %eax
cmpq $0x20, %rax
je 0x2cfd
andl $0x0, 0x8(%rdi,%rax,4)
incq %rax
jmp 0x2ced
movabsq $-0x7edcba93ff000000, %rax # imm = 0x8123456C01000000
movq %rax, 0x80(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::setiRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void MIPS::CPU::setiRegister(std::string reg, uint32_t val) {
  #define IREG(name_str, var) if (reg == name_str) var = val;
    IREG("RA", RA);
    IREG("RB", RB);
    IREG("RZ", RZ);
    IREG("RM", RM);
    IREG("RY", RY);
    IREG("IR", IR);
    IREG("PC", PC);
    IREG("hi", hi);
    IREG("lo", lo);
  #undef IREG
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x43ae(%rip), %rsi      # 0x70e0
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2d45
movl %ebx, 0xa4(%r14)
leaq 0x4397(%rip), %rsi      # 0x70e3
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2d5f
movl %ebx, 0xa8(%r14)
leaq 0x4380(%rip), %rsi      # 0x70e6
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2d79
movl %ebx, 0xac(%r14)
leaq 0x4369(%rip), %rsi      # 0x70e9
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2d93
movl %ebx, 0xb0(%r14)
leaq 0x4352(%rip), %rsi      # 0x70ec
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2dad
movl %ebx, 0xb4(%r14)
leaq 0x433b(%rip), %rsi      # 0x70ef
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2dc7
movl %ebx, 0x88(%r14)
leaq 0x4324(%rip), %rsi      # 0x70f2
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2de1
movl %ebx, 0x8c(%r14)
leaq 0x430d(%rip), %rsi      # 0x70f5
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2dfb
movl %ebx, 0x90(%r14)
leaq 0x42f6(%rip), %rsi      # 0x70f8
movq %r15, %rdi
callq 0x32ea
testb %al, %al
je 0x2e15
movl %ebx, 0x94(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop