LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::MaxInSection(unsigned long, unsigned long, unsigned long, unsigned long)
double Matrix::MaxInSection(size_t i_start, size_t i_end, size_t j_start, size_t j_end)
{
    // find max element in section [i_start, i_end), and [j_start, j_end)
    // in this code, we all follow the rule: close front and open end
    // and all counters start from 0
    auto dim = Dimension();
    if((int)i_start < 0 || (int)j_start < 0 || i_end <= i_start || j_end <= j_start || i_end > dim.first || j_end > dim.second){
        std::cout<<"Error: Max in matrix section: exceeded range."<<std::endl;
        exit(0);
    }
    double res = __M[i_start][j_start];
    for(size_t i=i_start;i<i_end;i++){
        for(size_t j=j_start;j<j_end;j++){
            if(res < __M[i][j])
                res = __M[i][j];
        }
    }
    return res;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3bae0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x0, %eax
jl 0x3e8da
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jl 0x3e8da
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jbe 0x3e8da
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jbe 0x3e8da
movq 0x50(%rsp), %rax
cmpq 0x30(%rsp), %rax
ja 0x3e8da
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x3e903
movq 0x2c6f7(%rip), %rdi     # 0x6afd8
leaq 0x16aa1(%rip), %rsi     # 0x55389
callq 0x4230
movq %rax, %rdi
movq 0x2c6b9(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x3e9de
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x3e9c9
movq 0x10(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1fd60
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3e9b7
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x3e9b9
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3e94d
jmp 0x3e9cb
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3e933
movsd 0x28(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::Transpose()
Matrix Matrix::Transpose()
{
    // transpose current matrix
    auto d = Dimension();
    Matrix _m(d.second, d.first);
    for(size_t i=0;i<d.first;i++){
        for(size_t j=0;j<d.second;j++){
            _m[j][i] = __M[i][j];
        }
    }
    return _m;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3bae0
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x37(%rsp)
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x3b3b0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x3eada
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x3eac5
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3ea5f
jmp 0x3eac7
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x3ea46
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x3eaf0
movq 0x18(%rsp), %rdi
callq 0x3bb80
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::FillElementByRow(unsigned long, double)
void Matrix::FillElementByRow(size_t index, double v)
{
    // fill an element to this matrix, row first
    auto dim = Dimension();
    size_t i = index/dim.second;
    size_t j = index%dim.second;
    if(i >= dim.first || j>= dim.second) {
        std::cout<<"Error: filling matrix exceeded range."<<std::endl;
        exit(0);
    }
    __M[i][j] = v;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3bae0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x28(%rsp)
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x28(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x3ec5b
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x3ec84
movq 0x2c376(%rip), %rdi     # 0x6afd8
leaq 0x1640a(%rip), %rsi     # 0x55073
callq 0x4230
movq %rax, %rdi
movq 0x2c338(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::FillElementByCollum(unsigned long, double)
void Matrix::FillElementByCollum(size_t index, double v)
{
    // fill an element to this matrix, collum first
    auto dim = Dimension();
    size_t i = index%dim.first;
    size_t j = index/dim.first;
    if(i >= dim.first || j>= dim.second) {
        std::cout<<"Error: filling matrix exceeded range."<<std::endl;
        exit(0);
    }
    __M[i][j] = v;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3bae0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x20(%rsp)
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x3ed2b
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x3ed54
movq 0x2c2a6(%rip), %rdi     # 0x6afd8
leaq 0x1633a(%rip), %rsi     # 0x55073
callq 0x4230
movq %rax, %rdi
movq 0x2c268(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::ElementSum()
double Matrix::ElementSum()
{
    // sum all elements together
    double res = 0;
    auto dim = Dimension();
    for(size_t i=0;i<dim.first;i++){
        for(size_t j=0;j<dim.second;j++){
            res += __M[i][j];
        }
    }
    return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x3bae0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x3ee31
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x3ee1f
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3edd8
jmp 0x3ee21
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3edc3
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::DispatchMatrix(Matrix&, unsigned long, unsigned long)
std::vector<Matrix> Matrix::DispatchMatrix(Matrix & M, size_t R, size_t C)
{
    // dispatch one big matrix to multiple small matrix'es, 
    // return in vector form
    // small matrix dimension R, C
    std::vector<Matrix> res;
    auto dim = M.Dimension();
    if( (dim.first*dim.second) % (R*C) != 0) {
        std::cout<<"Error: dispatch matrix dimension not match."<<std::endl;
        exit(0);
    }

    size_t index = 0;
    Matrix tmp(R, C);

    for(size_t i=0;i<dim.first;i++)
    {
        for(size_t j=0;j<dim.second;j++){
            tmp.FillElementByRow(index, M[i][j]);
            index++;
            if(index == R*C) {
                res.push_back(tmp);
                index = 0;
            }
        }
    }
    return res;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movb $0x0, 0x87(%rsp)
callq 0x1f050
movq 0x98(%rsp), %rdi
callq 0x3bae0
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x3f6ca
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rax
imulq 0x78(%rsp), %rax
movq 0x90(%rsp), %rcx
imulq 0x88(%rsp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x3f74c
movq 0x2b8cc(%rip), %rdi     # 0x6afd8
leaq 0x15a78(%rip), %rsi     # 0x5518b
callq 0x4230
movq %rax, 0x8(%rsp)
jmp 0x3f71f
movq 0x8(%rsp), %rdi
movq 0x2b885(%rip), %rsi     # 0x6afb0
callq 0x4260
jmp 0x3f732
xorl %edi, %edi
callq 0x4290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x3f89b
movq $0x0, 0x58(%rsp)
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x3b3b0
jmp 0x3f771
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x70(%rsp), %rax
jae 0x3f868
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x3f853
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1fd60
movq (%rsp), %rsi
movsd (%rax), %xmm0
leaq 0x40(%rsp), %rdi
callq 0x3ebf0
jmp 0x3f7df
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rsp), %rcx
imulq 0x88(%rsp), %rcx
cmpq %rcx, %rax
jne 0x3f83e
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1fa50
jmp 0x3f819
movq $0x0, 0x58(%rsp)
jmp 0x3f83e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3bb80
jmp 0x3f89b
jmp 0x3f840
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3f793
jmp 0x3f855
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x3f77a
movb $0x1, 0x87(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3bb80
testb $0x1, 0x87(%rsp)
jne 0x3f88e
movq 0x10(%rsp), %rdi
callq 0x1f0d0
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x1f0d0
movq 0x68(%rsp), %rdi
callq 0x43f0
nop
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::ConcatenateMatrixByI(Matrix&, Matrix&)
Matrix Matrix::ConcatenateMatrixByI(Matrix &A, Matrix &B)
{
    // vertially place two matrix together, 
    auto dimA = A.Dimension();
    auto dimB = B.Dimension();
    if(dimA.second != dimB.second){
        std::cout<<"Error: place two matrix together vertically, dimension not match."<<std::endl;
        exit(0);
    }

    Matrix C(dimA.first + dimB.first, dimA.second);
    for(size_t i=0;i<dimA.first;i++){
        for(size_t j=0;j<dimA.second;j++){
            C[i][j] = A[i][j];
        }
    }
    for(size_t i=dimA.first;i<dimA.first+dimB.first;i++){
        for(size_t j=0;j<dimB.second;j++){
            C[i][j] = B[i-dimA.first][j];
        }
    }
    return C;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x3f933
movq 0x2b6c7(%rip), %rdi     # 0x6afd8
leaq 0x1589f(%rip), %rsi     # 0x551b7
callq 0x4230
movq %rax, %rdi
movq 0x2b689(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x18(%rsp), %rdi
movb $0x0, 0x4f(%rsp)
movq 0x60(%rsp), %rsi
addq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x3b3b0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0x3f9f0
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x3f9db
movq 0x78(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x1fd60
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x3f973
jmp 0x3f9dd
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x3f95a
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x60(%rsp), %rcx
addq 0x50(%rsp), %rcx
cmpq %rcx, %rax
jae 0x3fa9d
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x3fa88
movq 0x70(%rsp), %rdi
movq 0x30(%rsp), %rsi
subq 0x60(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x1fd60
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x3fa1b
jmp 0x3fa8a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3f9fa
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x3fab3
movq 0x18(%rsp), %rdi
callq 0x3bb80
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::ConcatenateMatrixByJ(Matrix&, Matrix&)
Matrix Matrix::ConcatenateMatrixByJ(Matrix &A, Matrix &B)
{
    // horizontally place two matrix together, 
    auto dimA = A.Dimension();
    auto dimB = B.Dimension();
    if(dimA.first != dimB.first){
        std::cout<<"Error: place two matrix together horizontally, dimension not match."<<std::endl;
        exit(0);
    }

    Matrix C(dimA.first, dimA.second + dimB.second);
    for(size_t j=0;j<dimA.second;j++){
        for(size_t i=0;i<dimA.first;i++){
            C[i][j] = A[i][j];
        }
    }
    for(size_t j=dimA.second;j<dimA.second+dimB.second;j++){
        for(size_t i=0;i<dimB.first;i++){
            C[i][j] = B[i][j-dimA.second];
        }
    }
    return C;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x40123
movq 0x2aed7(%rip), %rdi     # 0x6afd8
leaq 0x1520f(%rip), %rsi     # 0x55317
callq 0x4230
movq %rax, %rdi
movq 0x2ae99(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x18(%rsp), %rdi
movb $0x0, 0x4f(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
addq 0x58(%rsp), %rdx
callq 0x3b3b0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x401e0
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0x401cb
movq 0x78(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x1fd60
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x40163
jmp 0x401cd
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x4014a
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x68(%rsp), %rcx
addq 0x58(%rsp), %rcx
cmpq %rcx, %rax
jae 0x4028d
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x40278
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x30(%rsp), %rsi
subq 0x68(%rsp), %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1fd60
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4020b
jmp 0x4027a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x401ea
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x402a3
movq 0x18(%rsp), %rdi
callq 0x3bb80
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::MaxInSection(unsigned long, unsigned long, unsigned long, unsigned long, std::pair<unsigned long, unsigned long>&)
double Matrix::MaxInSection(size_t i_start, size_t i_end, size_t j_start, size_t j_end, std::pair<size_t, size_t> &coord)
{
    // find max element in section [i_start, i_end), and [j_start, j_end)
    // in this code, we all follow the rule: close front and open end
    // and all counters start from 0
    auto dim = Dimension();
    if((int)i_start < 0 || (int)j_start < 0 || i_end <= i_start || j_end <= j_start || i_end > dim.first || j_end > dim.second){
        std::cout<<"Error: Max in matrix section: exceeded range."<<std::endl;
        exit(0);
    }
    double res = __M[i_start][j_start];
    for(size_t i=i_start;i<i_end;i++){
        for(size_t j=j_start;j<j_end;j++)
        {
            if(res < __M[i][j]){
                res = __M[i][j];
                coord.first = i;
                coord.second = j;
            }
        }
    }
    return res;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3bae0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x0, %eax
jl 0x4038f
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jl 0x4038f
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jbe 0x4038f
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jbe 0x4038f
movq 0x50(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x4038f
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x403b8
movq 0x2ac42(%rip), %rdi     # 0x6afd8
leaq 0x14fec(%rip), %rsi     # 0x55389
callq 0x4230
movq %rax, %rdi
movq 0x2ac04(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x404b3
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x4049e
movq 0x8(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x40489
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4048b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x40402
jmp 0x404a0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x403e8
movsd 0x20(%rsp), %xmm0
addq $0x68, %rsp
retq
nop
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::SumInSection(unsigned long, unsigned long, unsigned long, unsigned long)
double Matrix::SumInSection(size_t i_start, size_t i_end, size_t j_start, size_t j_end)
{
    // find element sum in section [i_start, i_end), and [j_start, j_end)
    // in this code, we all follow the rule: close front and open end
    // and all counters start from 0
    auto dim = Dimension();
    if((int)i_start < 0 || (int)j_start < 0 || i_end <= i_start || j_end <= j_start || i_end > dim.first || j_end > dim.second){
        std::cout<<"Error: Sum in matrix section: exceeded range."<<std::endl;
        exit(0);
    }
    double res =  0;
    for(size_t i=i_start;i<i_end;i++){
        for(size_t j=j_start;j<j_end;j++){
            res += __M[i][j];
        }
    }

    return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3bae0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jl 0x40869
movq 0x38(%rsp), %rax
cmpl $0x0, %eax
jl 0x40869
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jbe 0x40869
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x40869
movq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x40869
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x40892
movq 0x2a768(%rip), %rdi     # 0x6afd8
leaq 0x14c38(%rip), %rsi     # 0x554af
callq 0x4230
movq %rax, %rdi
movq 0x2a72a(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x40914
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x40902
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x408bb
jmp 0x40904
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x408a5
movsd 0x18(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::AverageInSection(unsigned long, unsigned long, unsigned long, unsigned long)
double Matrix::AverageInSection(size_t i_start, size_t i_end, size_t j_start, size_t j_end)
{
    // find element average in section [i_start, i_end), and [j_start, j_end)
    // in this code, we all follow the rule: close front and open end
    // and all counters start from 0
    auto dim = Dimension();
    if((int)i_start < 0 || (int)j_start < 0 || i_end <= i_start || j_end <= j_start || i_end > dim.first || j_end > dim.second){
        std::cout<<"Error: Max in matrix section: exceeded range."<<std::endl;
        exit(0);
    }
    double res =  0;
    for(size_t i=i_start;i<i_end;i++){
        for(size_t j=j_start;j<j_end;j++){
            res += __M[i][j];
        }
    }

    res = res /(int)(i_end-i_start)/(int)(j_end - j_start); 
    return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3bae0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jl 0x40bd9
movq 0x38(%rsp), %rax
cmpl $0x0, %eax
jl 0x40bd9
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jbe 0x40bd9
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x40bd9
movq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x40bd9
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x40c02
movq 0x2a3f8(%rip), %rdi     # 0x6afd8
leaq 0x147a2(%rip), %rsi     # 0x55389
callq 0x4230
movq %rax, %rdi
movq 0x2a3ba(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x40c84
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x40c72
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x40c2b
jmp 0x40c74
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x40c15
movsd 0x18(%rsp), %xmm0
movq 0x40(%rsp), %rax
subq 0x48(%rsp), %rax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
subq 0x38(%rsp), %rax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::Rot_180()
Matrix Matrix::Rot_180()
{
    // rotate matrix by 180 degree
    auto dim = this->Dimension();
    Matrix _m(dim);

    for(size_t i=0;i<dim.first;i++){
        for(size_t j=0;j<dim.second;j++){
            _m[i][j] = (*this)[dim.first - i -1][dim.second - j-1];
        }
    }

    return _m;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3bae0
movq 0x18(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x47(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x3b4a0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x410c0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x410ab
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
subq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x50(%rsp), %rsi
subq 0x20(%rsp), %rsi
subq $0x1, %rsi
callq 0x1fd60
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x41033
jmp 0x410ad
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4101a
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x410d6
movq 0x18(%rsp), %rdi
callq 0x3bb80
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::GetCorrelationValue(Matrix&, Matrix&, unsigned long, unsigned long)
double Matrix::GetCorrelationValue(Matrix &A, Matrix &B, size_t i, size_t j)
{
    // get the element (i, j) of the correlated matrix, A is input matrix, B is kernel
    // keep in mind this one does not care about matrix dimension, it will fill with 0 value
    // for non-exist matrix elements
    if( (int)i<0 || (int)j<0) {
        std::cout<<"Error: wrong index in get correlation value."<<std::endl;
        exit(0);
    }

    auto dimA = A.Dimension();
    auto dimB = B.Dimension();

    double res = 0;
    for(size_t p = 0; p<dimB.first;p++)
    {
        for(size_t q=0; q<dimB.second;q++){
            int index_i_A = (int)i + (int)p;
            int index_j_A = (int)j + (int)q;

            if(index_i_A < 0 || index_i_A >= (int)dimA.first || index_j_A < 0 || index_j_A >= (int)dimA.second) {
                res += 0.; // 0*B[p][q];
            } else {
                res += A[index_i_A][index_j_A] * B[p][q];
            }
        }
    }
    return res;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpl $0x0, %eax
jl 0x4170c
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jge 0x41735
movq 0x298c5(%rip), %rdi     # 0x6afd8
leaq 0x13f18(%rip), %rsi     # 0x55632
callq 0x4230
movq %rax, %rdi
movq 0x29887(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x60(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x41879
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x41864
movq 0x50(%rsp), %rax
movq 0x18(%rsp), %rcx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
addl %ecx, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x417e0
movl 0xc(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl %ecx, %eax
jge 0x417e0
cmpl $0x0, 0x8(%rsp)
jl 0x417e0
movl 0x8(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl %ecx, %eax
jl 0x417f1
xorps %xmm0, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x4184f
movq 0x60(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movslq 0x8(%rsp), %rsi
callq 0x1fd60
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1fd60
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x41851
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x41788
jmp 0x41866
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4176f
movsd 0x20(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::DeleteRow(unsigned long)
void Matrix::DeleteRow(size_t i)
{
    // delete a row
    auto dim = Dimension();
    if(i>= dim.first || (int)i<0) {
        std::cout<<"Warning: deleting matrix row, index out of range."<<std::endl;
        return;
    }

    __M.erase(__M.begin() + i);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3bae0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x41f6c
movq 0x38(%rsp), %rax
cmpl $0x0, %eax
jge 0x41f90
movq 0x29065(%rip), %rdi     # 0x6afd8
leaq 0x13712(%rip), %rsi     # 0x5568c
callq 0x4230
movq %rax, %rdi
movq 0x29027(%rip), %rsi     # 0x6afb0
callq 0x4260
jmp 0x41fd4
movq (%rsp), %rdi
callq 0x25ca0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x26c70
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x429b0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x42940
movq %rax, 0x8(%rsp)
addq $0x48, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::DeleteCollum(unsigned long)
void Matrix::DeleteCollum(size_t i)
{
    // delete a collum
    auto dim = Dimension();
    if((int)i<0 || i>= dim.second){
        std::cout<<"Warning: deleting matrix collum, index out of range."<<std::endl;
        return;
    }
    for(size_t j=0;j<dim.first;j++){
        __M[j].erase(__M[j].begin()+i);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3bae0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x0, %eax
jl 0x4201d
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x42044
movq 0x28fb4(%rip), %rdi     # 0x6afd8
leaq 0x13693(%rip), %rsi     # 0x556be
callq 0x4230
movq %rax, %rdi
movq 0x28f76(%rip), %rsi     # 0x6afb0
callq 0x4260
jmp 0x420d1
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x420d1
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x42670
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
movq 0x30(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
callq 0x21d50
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x27450
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x42a60
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x429f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x4204d
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::InsertRow(unsigned long, std::vector<double, std::allocator<double>>*)
void Matrix::InsertRow(size_t i, std::vector<double>* vec)
{
    // insert vec to matrix at position i
    auto dim = Dimension();
    if(vec!=nullptr && vec->size() != dim.second){
        std::cout<<"Error: inserting row to matrix, dimension not match."<<std::endl;
        exit(0);
    }
    if((int)i<0 || i>dim.first){
        std::cout<<"Error: insert row to matrix, wrong position."<<std::endl;
        exit(0);
    }
    if(vec == nullptr){
        std::vector<double> v(dim.second, 0);
        __M.insert(__M.begin()+i, v);
    } else {
        __M.insert(__M.begin()+i, (*vec));
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3bae0
movq %rax, 0xa0(%rsp)
movq %rdx, 0xa8(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x4216c
movq 0xb0(%rsp), %rdi
callq 0x21e20
cmpq 0xa8(%rsp), %rax
je 0x4216c
movq 0x28e8e(%rip), %rdi     # 0x6afd8
leaq 0x135a2(%rip), %rsi     # 0x556f3
callq 0x4230
movq %rax, %rdi
movq 0x28e50(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0xb8(%rsp), %rax
cmpl $0x0, %eax
jl 0x4218b
movq 0xb8(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jbe 0x421b4
movq 0x28e46(%rip), %rdi     # 0x6afd8
leaq 0x1358f(%rip), %rsi     # 0x55728
callq 0x4230
movq %rax, %rdi
movq 0x28e08(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
cmpq $0x0, 0xb0(%rsp)
jne 0x422bc
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x222f0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x425f0
jmp 0x4220c
leaq 0x7f(%rsp), %rdi
callq 0x26280
movq 0x20(%rsp), %rdi
callq 0x25ca0
movq %rax, 0x50(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x26c70
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x429b0
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x42aa0
movq %rax, 0x8(%rsp)
jmp 0x42269
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1f190
jmp 0x4230d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x26280
jmp 0x42315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1f190
jmp 0x42315
movq 0x20(%rsp), %rdi
callq 0x25ca0
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x26c70
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x429b0
movq 0x20(%rsp), %rdi
movq 0xb0(%rsp), %rdx
movq 0x40(%rsp), %rsi
callq 0x42aa0
movq %rax, 0x28(%rsp)
addq $0xc8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x43f0
nop
// File: xbai0624[P]dnn/src/Matrix.cpp
// Function: Matrix::InsertCollum(unsigned long, std::vector<double, std::allocator<double>>*)
void Matrix::InsertCollum(size_t i, std::vector<double>* vec)
{
    // insert vec to matrix at position i
    auto dim=Dimension();
    if(vec!=nullptr && vec->size() != dim.first){
        std::cout<<"Error: inserting col to matrix, dimension not match."<<std::endl;
        exit(0);
    }
    if((int)i<0 || i>dim.second){
        std::cout<<"Error: insert col to matrix, wrong position."<<std::endl;
        exit(0);
    }
    for(size_t ii=0;ii<dim.first;ii++){
        if(vec == nullptr){
            __M[ii].insert(__M[ii].begin() + i, 0);
        } else {
            __M[ii].insert(__M[ii].begin() + i, (*vec)[ii]);
        }
    }
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3bae0
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0x423a3
movq 0x80(%rsp), %rdi
callq 0x21e20
cmpq 0x70(%rsp), %rax
je 0x423a3
movq 0x28c57(%rip), %rdi     # 0x6afd8
leaq 0x133cd(%rip), %rsi     # 0x55755
callq 0x4230
movq %rax, %rdi
movq 0x28c19(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq 0x88(%rsp), %rax
cmpl $0x0, %eax
jl 0x423bf
movq 0x88(%rsp), %rax
cmpq 0x78(%rsp), %rax
jbe 0x423e8
movq 0x28c12(%rip), %rdi     # 0x6afd8
leaq 0x133bd(%rip), %rsi     # 0x5578a
callq 0x4230
movq %rax, %rdi
movq 0x28bd4(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq $0x0, 0x68(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x70(%rsp), %rax
jae 0x4251a
cmpq $0x0, 0x80(%rsp)
jne 0x42486
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x42670
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
callq 0x21d50
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x27450
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x42a60
movq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x42cb0
movq %rax, 0x40(%rsp)
jmp 0x42505
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x42670
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
callq 0x42670
movq %rax, %rdi
callq 0x21d50
movq %rax, 0x28(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x27450
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x42a60
movq 0x80(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1fd60
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x38(%rsp), %rsi
callq 0x42cf0
movq %rax, 0x20(%rsp)
jmp 0x42507
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x423f1
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: xbai0624[P]dnn/src/Network.cpp
// Function: Network::UpdateEpoch()
void Network::UpdateEpoch()
{
    int numberofBatches = __dataInterface -> GetNumberOfBatches();
    cout<<"......Info: "<<numberofBatches<<" batches in this epoch"<<endl;
    numberofBatches = 1; // test QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQqq

    __dataInterface->Reset();
    __dataInterface->Shuffle();

    // initializations for epoch
    for(auto &i: __middleAndOutputLayers)
    {
        i->EpochInit();
    }

    for(int i=0;i<numberofBatches;i++)
    {
        cout<<"......... training for batch: "<<i<<"/"<<numberofBatches<<endl;
        UpdateBatch();
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
callq 0x39a70
movl %eax, 0x3c(%rsp)
movq 0x24fc1(%rip), %rdi     # 0x6afd8
leaq 0xf8f2(%rip), %rsi      # 0x55910
callq 0x4230
movq %rax, %rdi
movl 0x3c(%rsp), %esi
callq 0x43e0
movq %rax, %rdi
leaq 0xf8e4(%rip), %rsi      # 0x5591d
callq 0x4230
movq %rax, %rdi
movq 0x24f68(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rax
movl $0x1, 0x3c(%rsp)
movq 0x28(%rax), %rdi
callq 0x3a2a0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x3a2c0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x469a0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x469d0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x46a00
testb $0x1, %al
jne 0x460ae
jmp 0x460d7
leaq 0x28(%rsp), %rdi
callq 0x46a40
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x46a50
jmp 0x46099
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x46149
movq 0x24ee8(%rip), %rdi     # 0x6afd8
leaq 0xf83d(%rip), %rsi      # 0x55934
callq 0x4230
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x43e0
movq %rax, %rdi
leaq 0xf7ec(%rip), %rsi      # 0x558fe
callq 0x4230
movq %rax, %rdi
movl 0x3c(%rsp), %esi
callq 0x43e0
movq %rax, %rdi
movq 0x24e83(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rdi
callq 0x46150
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x460df
addq $0x48, %rsp
retq
nop
// File: xbai0624[P]dnn/src/Network.cpp
// Function: Network::UpdateBatch()
void Network::UpdateBatch()
{
    // initializations for batch
    for(auto &i: __middleAndOutputLayers)
        i->BatchInit();

    auto t1 = std::chrono::high_resolution_clock::now();
    ForwardPropagateForBatch();
    //auto t2 = std::chrono::high_resolution_clock::now();
    //auto dt1 = std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1);
    //std::cout<<"forward propagation cost: "<<dt1.count()<<" milliseconds"<<endl;

    BackwardPropagateForBatch();
    //auto t3 = std::chrono::high_resolution_clock::now();
    //auto dt2 = std::chrono::duration_cast<std::chrono::milliseconds>(t3-t2);
    //std::cout<<"backward propagation cost: "<<dt2.count()<<" milliseconds"<<endl;

    UpdateWeightsAndBiasForBatch();
    auto t4 = std::chrono::high_resolution_clock::now();
    auto dt3 = std::chrono::duration_cast<std::chrono::milliseconds>(t4-t1);
    std::cout<<"        batch training cost: "<<dt3.count()<<" milliseconds"<<endl;

    // save training accuracy for batch
    __outputLayer -> SaveAccuracyAndCostForBatch();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x469a0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x469d0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x46a00
testb $0x1, %al
jne 0x4619b
jmp 0x461c7
leaq 0x40(%rsp), %rdi
callq 0x46a40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
leaq 0x40(%rsp), %rdi
callq 0x46a50
jmp 0x46186
callq 0x4040
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x46280
movq 0x8(%rsp), %rdi
callq 0x46330
movq 0x8(%rsp), %rdi
callq 0x46390
callq 0x4040
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46aa0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x46a70
movq %rax, 0x18(%rsp)
movq 0x24db5(%rip), %rdi     # 0x6afd8
leaq 0xf729(%rip), %rsi      # 0x55953
callq 0x4230
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x46af0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4430
movq %rax, %rdi
leaq 0xf71e(%rip), %rsi      # 0x55971
callq 0x4230
movq %rax, %rdi
movq 0x24d4e(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x2d0(%rax)
addq $0x58, %rsp
retq
nop
// File: xbai0624[P]dnn/src/Network.cpp
// Function: Network::ForwardPropagateForBatch()
void Network::ForwardPropagateForBatch()
{
    // prepare new batch data and label in Datainterface class
    __dataInterface->GetNewBatchData();
    __dataInterface->GetNewBatchLabel();

    // fill data to input layer
    __inputLayer->FillBatchDataToInputLayerA();

    // forward propagation
    for(auto &i: __middleAndOutputLayers)
    {
        i->ForwardPropagateForBatch();
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
callq 0x39b20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x3a030
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x469a0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x469d0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x46a00
testb $0x1, %al
jne 0x462f9
jmp 0x46322
leaq 0x20(%rsp), %rdi
callq 0x46a40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x20(%rsp), %rdi
callq 0x46a50
jmp 0x462e4
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: xbai0624[P]dnn/src/Network.cpp
// Function: Network::BackwardPropagateForBatch()
void Network::BackwardPropagateForBatch() 
{
    // backward
    int NLayers = __middleAndOutputLayers.size();

    for(int nlayer=NLayers-1; nlayer>=0; nlayer--)
        __middleAndOutputLayers[nlayer]->BackwardPropagateForBatch();

    /// no need for input layer
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x46b00
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x46381
movq (%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x46b20
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46356
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::UpdateZ(int)
void Neuron::UpdateZ(int sample_index)
{
    // update z for current layer
    if(__layer->GetType() == LayerType::fullyConnected || __layer->GetType() == LayerType::output)
    {
        //std::cout<<__func__<<" fully connected layer update z"<<std::endl;
        UpdateZFC(sample_index);
    } 
    else if(__layer->GetType() == LayerType::cnn)
    {
        //std::cout<<__func__<<" cnn layer update z"<<std::endl;
        UpdateZCNN(sample_index);
    } 
    else if(__layer->GetType() == LayerType::pooling)
    {
        //std::cout<<__func__<<" pooling layer update z"<<std::endl;
        UpdateZPooling(sample_index);
    } 
    else 
    {
        std::cout<<"Error: unsupported layer type."<<std::endl;
        exit(0);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x0, %eax
je 0x476be
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x4, %eax
jne 0x476cd
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x48140
jmp 0x47744
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x1, %eax
jne 0x476f2
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x484b0
jmp 0x47742
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x2, %eax
jne 0x47717
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x487e0
jmp 0x47740
movq 0x238ba(%rip), %rdi     # 0x6afd8
leaq 0xe33a(%rip), %rsi      # 0x55a5f
callq 0x4230
movq %rax, %rdi
movq 0x2387c(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
jmp 0x47742
jmp 0x47744
addq $0x18, %rsp
retq
nopl (%rax)
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::UpdateDelta(int)
void Neuron::UpdateDelta(int sample_index)
{
    // update delta for current layer
    if(__layer->GetType() == LayerType::output)
    {
        UpdateDeltaOutputLayer(sample_index);
    } 
    else if(__layer->GetType() == LayerType::fullyConnected)
    {
        UpdateDeltaFC(sample_index);
    } 
    else if(__layer->GetType() == LayerType::cnn)
    {
        UpdateDeltaCNN(sample_index);
    } 
    else if(__layer->GetType() == LayerType::pooling)
    {
        UpdateDeltaPooling(sample_index);
    } 
    else 
    {
        std::cout<<"Error: unsupported layer type."<<std::endl;
        exit(0);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x4, %eax
jne 0x47caa
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x489f0
jmp 0x47d48
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x0, %eax
jne 0x47ccf
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x48ce0
jmp 0x47d46
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x1, %eax
jne 0x47cf4
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x48fd0
jmp 0x47d44
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x2, %eax
jne 0x47d19
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x49a10
jmp 0x47d42
movq 0x232b8(%rip), %rdi     # 0x6afd8
leaq 0xdd38(%rip), %rsi      # 0x55a5f
callq 0x4230
movq %rax, %rdi
movq 0x2327a(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
jmp 0x47d44
jmp 0x47d46
jmp 0x47d48
addq $0x18, %rsp
retq
nopl (%rax)