LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator*=(std::complex<double>)
void Matrix::operator*=(complex<double> d)
{
	type="complex";
	for (int iR = 0;iR<nRows;iR++)
		for (int iC = 0;iC<nColumns;iC++)
			cvalues[iR][iC] *= d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
addq $0x18, %rdi
leaq 0x4655(%rip), %rsi      # 0xf1f5
callq 0x35a0
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xabe0
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xabdb
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0xe4f4
incq %r13
addq $0x10, %r12
jmp 0xabb6
incq %r15
jmp 0xaba8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator/(Matrix&)
Matrix Matrix::operator/(Matrix& m) //C = A/B where C, A and B are all matrices
{
	Matrix r = *this;
	Matrix ret;
	ret = r.div(m);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %rdi
callq 0x8daa
movq %rbx, %rdi
callq 0x89d6
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %r14, %rdx
callq 0xacf6
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %rbx, %rsi
callq 0x9e42
leaq -0xb8(%rbp), %rdi
callq 0x8a24
leaq -0x48(%rbp), %rdi
callq 0x8a24
leaq -0x80(%rbp), %rdi
callq 0x8a24
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x8a24
jmp 0xacd8
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
jmp 0xace5
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::div(Matrix&)
Matrix Matrix::div(Matrix& m)//div C = A/B = A * B.getInverse();
{
	Matrix r = *this;
	if (nColumns != m.nRows)
		throw("First matrix must have the same number of columns as the rows in the second matrix.");
	Matrix t ;
	t= m.getInverse(); // get the inverse of B
	r *= t;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x8daa
movl 0x4(%r15), %eax
cmpl (%r14), %eax
jne 0xad8a
leaq -0x50(%rbp), %rdi
callq 0x89d6
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0xaeea
leaq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x9e42
leaq -0xc0(%rbp), %rdi
callq 0x8a24
leaq -0x88(%rbp), %rdi
callq 0x8a24
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xa62a
leaq -0x50(%rbp), %rdi
callq 0x8a24
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x44f1(%rip), %rcx      # 0xf28a
movq %rcx, (%rax)
movq 0x9225(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
jmp 0xadc0
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x8a24
jmp 0xadc3
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x8a24
jmp 0xadd3
jmp 0xadd0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator/(double)
Matrix Matrix::operator/(double d) //C = A/B where C, A are matrices and B is a double
{
	Matrix r = *this;
	for (int iR = 0; iR<r.nRows; iR++)
		for (int iC = 0; iC<r.nColumns; iC++)
			r.values[iR][iC] /= d;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
callq 0x8daa
movsd -0x10(%rbp), %xmm1
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl (%rbx), %edx
testl %edx, %edx
cmovlel %ecx, %edx
cmpq %rdx, %rcx
je 0xae3b
movq 0x8(%rbx), %rsi
xorl %edi, %edi
cmpq %rdi, %rax
je 0xae36
movq (%rsi,%rcx,8), %r8
movsd (%r8,%rdi,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0xae18
incq %rcx
jmp 0xae0d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator-()
Matrix Matrix::operator-()
{
	for (int iR = 0;iR < nRows;iR++)
	{
		for (int iC = 0;iC < nColumns;iC++)
			values[iR][iC] = -values[iR][iC];
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
testl %eax, %eax
cmovlel %edx, %eax
movaps 0x3c35(%rip), %xmm0     # 0xf1c0
cmpq %rax, %rdx
je 0xb5b8
movq 0x8(%rsi), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0xb5b3
movq (%rdi,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r9,%r8,8)
incq %r8
jmp 0xb597
incq %rdx
jmp 0xb58b
movq %rbx, %rdi
callq 0x8daa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getSubMatrix(int, int, int, int)
Matrix Matrix::getSubMatrix(int r, int c, int nRows, int nColumns)
{
	if ((r + nRows)>nRows || (c + nColumns)>nColumns)
		throw("Invalid matrix dimension");
		if(this->type=="complex")
        {
            Matrix m("complex",nRows, nColumns);
	for (int iR = 0;iR<m.nRows;iR++)
		for (int iC = 0;iC<m.nColumns;iC++)
			m.cvalues[iR][iC] = cvalues[r + iR][c + iC];
	return m;
        }
		else{
	Matrix m(nRows, nColumns);
	for (int iR = 0;iR<m.nRows;iR++)
		for (int iC = 0;iC<m.nColumns;iC++)
			m.values[iR][iC] = values[r + iR][c + iC];
	return m;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, -0x30(%rbp)
testl %edx, %edx
jg 0xb9cd
movl %ecx, %r12d
testl %ecx, %ecx
jg 0xb9cd
movl %r9d, %r13d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x394a(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xb94c
leaq 0x3936(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
movl -0x30(%rbp), %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
movslq %r12d, %rax
movslq %r15d, %rcx
shlq $0x4, %rax
xorl %edx, %edx
movslq (%rbx), %rsi
cmpq %rsi, %rdx
jge 0xb9bb
leaq (,%rdx,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0x4(%rbx), %r9
cmpq %r9, %r8
jge 0xb947
movq 0x10(%r14), %r9
addq %rsi, %r9
movq (%r9,%rcx,8), %r9
addq %rax, %r9
movq 0x10(%rbx), %r10
movq (%r10,%rdx,8), %r10
movups (%rdi,%r9), %xmm0
movups %xmm0, (%r10,%rdi)
incq %r8
addq $0x10, %rdi
jmp 0xb915
incq %rdx
jmp 0xb8fc
movl %r13d, %edx
xorl %r13d, %r13d
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl -0x30(%rbp), %esi
xorl %ecx, %ecx
callq 0x8ace
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
movslq %r12d, %rdx
testl %ecx, %ecx
cmovlel %r13d, %ecx
movslq %r15d, %rsi
testl %eax, %eax
cmovlel %r13d, %eax
shlq $0x3, %rdx
cmpq %rax, %r13
je 0xb9bb
leaq (,%r13,8), %rdi
addq 0x8(%r14), %rdi
movq 0x8(%rbx), %r8
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0xb9b6
movq (%rdi,%rsi,8), %r10
addq %rdx, %r10
movsd (%r10,%r9,8), %xmm0
movq (%r8,%r13,8), %r10
movsd %xmm0, (%r10,%r9,8)
incq %r9
jmp 0xb995
incq %r13
jmp 0xb97d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x3869(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x85e2(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getCofactor(int, int)
Matrix Matrix::getCofactor(int r, int c)
{
	//valid only for (2*2) matrices.
	if (nRows <= 1 && nColumns <= 1)
		throw("Invalid matrix dimension");
		if(this->type=="complex")
        {
          Matrix m("complex",nRows - 1, nColumns - 1);
	for (int iR = 0;iR<m.nRows;iR++)
		for (int iC = 0;iC<m.nColumns;iC++)
		{
			int sR = (iR<r) ? iR : iR + 1;
			int sC = (iC<c) ? iC : iC + 1;
			m.cvalues[iR][iC] = cvalues[sR][sC];
		}
		return m;
        }
        else
        {
	Matrix m(nRows - 1, nColumns - 1);
	for (int iR = 0;iR<m.nRows;iR++)
		for (int iC = 0;iC<m.nColumns;iC++)
		{
			int sR = (iR<r) ? iR : iR + 1;
			int sC = (iC<c) ? iC : iC + 1;
			m.values[iR][iC] = values[sR][sC];
		}
		return m;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jg 0xba31
cmpl $0x1, 0x4(%r14)
jle 0xbb92
leaq 0x18(%r14), %rdi
leaq 0x37b9(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xbaf9
leaq 0x37a5(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
decl %edx
decl %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r13, %rsi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
movslq %r12d, %rax
movslq %r15d, %rcx
xorl %edx, %edx
movslq (%rbx), %rsi
cmpq %rsi, %rdx
jge 0xbb80
xorl %esi, %esi
cmpq %rcx, %rdx
setge %sil
leaq (,%rdx,8), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movslq 0x4(%rbx), %r10
cmpq %r10, %r9
jge 0xbaf4
leaq 0x1(%r9), %r10
cmpq %rax, %r9
cmovgeq %r10, %r9
movq 0x10(%r14), %r11
addq %rdi, %r11
movq (%r11,%rsi,8), %r11
movl %r9d, %r9d
shlq $0x4, %r9
movq 0x10(%rbx), %r15
movq (%r15,%rdx,8), %r15
movups (%r11,%r9), %xmm0
movups %xmm0, (%r15,%r8)
addq $0x10, %r8
movq %r10, %r9
jmp 0xbab3
incq %rdx
jmp 0xba90
movl (%r14), %esi
movl 0x4(%r14), %edx
decl %esi
decl %edx
xorl %r13d, %r13d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
movslq %r12d, %rdx
testl %ecx, %ecx
cmovlel %r13d, %ecx
movslq %r15d, %rsi
testl %eax, %eax
cmovlel %r13d, %eax
cmpq %rax, %r13
je 0xbb80
xorl %edi, %edi
cmpq %rsi, %r13
setge %dil
leaq (,%r13,8), %r8
addq 0x8(%r14), %r8
movq 0x8(%rbx), %r9
xorl %r10d, %r10d
cmpq %r10, %rcx
je 0xbb7b
leaq 0x1(%r10), %r11
cmpq %rdx, %r10
movq %r11, %r15
cmovlq %r10, %r15
movq (%r8,%rdi,8), %r12
movl %r15d, %r15d
movsd (%r12,%r15,8), %xmm0
movq (%r9,%r13,8), %r15
movsd %xmm0, (%r15,%r10,8)
movq %r11, %r10
jmp 0xbb4c
incq %r13
jmp 0xbb2b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x36a4(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x841d(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getDeterminant()
double Matrix::getDeterminant()
{
	double result=0;
	int *p = new int [nRows+1];
		Matrix copy = *this;
		 if(LUPDecompose(copy.values,nRows,0.001,p)){
			 result= LUPDeterminant(copy.values,p,nRows);
			if(result>0 && result<0.01)result=0;
			 return result;
		 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movslq (%rdi), %rax
cmpq $-0x1, %rax
leaq 0x4(,%rax,4), %rax
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x3030
movq %rax, %r15
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8daa
movq 0x8(%rbx), %rdi
movl (%r14), %esi
movsd 0x355a(%rip), %xmm0     # 0xf170
movq %r15, %rdx
callq 0xbc6f
movq 0x8(%rbx), %rdi
movl (%r14), %edx
movq %r15, %rsi
callq 0xbdb7
xorpd %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0x3535(%rip), %xmm2     # 0xf178
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
movapd %xmm2, -0x30(%rbp)
movq %rbx, %rdi
callq 0x8a24
movaps -0x30(%rbp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: LUPDecompose(double**, int, double, int*)
int LUPDecompose(double **A, int N, double Tol, int *P) {

    int i, j, k, imax;
    double maxA, *ptr, absA;

    for (i = 0; i <= N; i++)
        P[i] = i; //Unit permutation matrix, P[N] initialized with N

    for (i = 0; i < N; i++) {
        maxA = 0.0;
        imax = i;

        for (k = i; k < N; k++)
            if ((absA = fabs(A[k][i])) > maxA) {
                maxA = absA;
                imax = k;
            }

        if (maxA < Tol) return 0; //failure, matrix is degenerate

        if (imax != i) {
            //pivoting P
            j = P[i];
            P[i] = P[imax];
            P[imax] = j;

            //pivoting rows of A
            ptr = A[i];
            A[i] = A[imax];
            A[imax] = ptr;

            //counting pivots starting from N (for determinant)
            P[N]++;
        }

        for (j = i + 1; j < N; j++) {
            A[j][i] /= A[i][i];

            for (k = i + 1; k < N; k++)
                A[j][k] -= A[j][i] * A[i][k];
        }
    }

    return 1;  //decomposition done
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rcx
movl %ecx, %r8d
xorl %eax, %eax
cmpq %rcx, %rax
jg 0xbc91
movl %eax, (%rdx,%rax,4)
incq %rax
jmp 0xbc84
movq %rcx, -0x30(%rbp)
xorl %r9d, %r9d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %rax, -0x38(%rbp)
movabsq $0x1, %rbx
movapd 0x3528(%rip), %xmm1     # 0xf1e0
movq %rbx, %rax
xorl %r14d, %r14d
cmpq -0x38(%rbp), %r14
je 0xbda3
xorpd %xmm2, %xmm2
movq %r14, %r10
movl %r14d, %r15d
cmpq %r10, %r8
je 0xbcfa
movq (%rdi,%r10,8), %r11
movsd (%r11,%r14,8), %xmm3
andpd %xmm1, %xmm3
ucomisd %xmm2, %xmm3
cmoval %r10d, %r15d
maxsd %xmm2, %xmm3
incq %r10
movapd %xmm3, %xmm2
jmp 0xbcd2
ucomisd %xmm2, %xmm0
ja 0xbdaa
movl %r15d, %r10d
cmpq %r10, %r14
je 0xbd36
movl (%rdx,%r14,4), %r10d
movslq %r15d, %r11
movl (%rdx,%r11,4), %r15d
movl %r15d, (%rdx,%r14,4)
movl %r10d, (%rdx,%r11,4)
movq (%rdi,%r14,8), %r10
movq (%rdi,%r11,8), %r15
movq %r15, (%rdi,%r14,8)
movq %r10, (%rdi,%r11,8)
movq -0x30(%rbp), %rcx
incl (%rdx,%rcx,4)
movq %rax, %r15
cmpl %esi, %r15d
jge 0xbd94
movq (%rdi,%r14,8), %r12
movq (%rdi,%r15,8), %r13
movsd (%r13,%r14,8), %xmm2
divsd (%r12,%r14,8), %xmm2
movsd %xmm2, (%r13,%r14,8)
leaq (%r9,%r13), %r10
addq %r9, %r12
movq %rbx, %r11
leal (%r14,%r11), %ecx
cmpl %r8d, %ecx
jge 0xbd8f
movsd (%r13,%r14,8), %xmm2
mulsd (%r12,%r11,8), %xmm2
movsd (%r10,%r11,8), %xmm3
subsd %xmm2, %xmm3
movsd %xmm3, (%r10,%r11,8)
incq %r11
jmp 0xbd64
incq %r15
jmp 0xbd39
incq %r14
incq %rax
addq $0x8, %r9
jmp 0xbcbe
movl $0x1, %eax
jmp 0xbdac
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: LUPDeterminant(double**, int*, int)
double LUPDeterminant(double **A, int *P, int N) {

    double det = A[0][0];

    for (int i = 1; i < N; i++)
        det *= A[i][i];

    if ((P[N] - N) % 2 == 0)
        return det;
    else
        return -det;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movsd (%rax), %xmm0
movslq %edx, %rax
movabsq $0x1, %rcx
cmpq %rax, %rcx
jge 0xbde2
movq (%rdi,%rcx,8), %rdx
mulsd (%rdx,%rcx,8), %xmm0
incq %rcx
jmp 0xbdcf
movl (%rsi,%rax,4), %ecx
subl %eax, %ecx
testb $0x1, %cl
je 0xbdf4
xorpd 0x33cc(%rip), %xmm0     # 0xf1c0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getcDeterminant()
complex<double> Matrix::getcDeterminant()
{
	//valid only when rows=columns.
if (nRows != nColumns)
	throw("Invalid matrix dimension");
if (nRows == 1 && nColumns == 1)return cvalues[0][0];
complex<double> value = 0;
double m = 1.0;
for (int iR = 0;iR<nRows;iR++)
{
	value += m * cvalues[0][iR] * getCofactor(0, iR).getcDeterminant();
	m *= -1;
}
return value;   //return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0xbf19
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0xbe32
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
jmp 0xbf07
xorpd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x3315(%rip), %xmm2     # 0xf158
pushq $0x8
popq %r12
xorl %r14d, %r14d
leaq -0xa8(%rbp), %r15
leaq -0x48(%rbp), %r13
movsd %xmm0, -0x30(%rbp)
cltq
cmpq %rax, %r14
jge 0xbefd
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd -0x8(%rax,%r12), %xmm0
mulsd %xmm2, %xmm0
movsd (%rax,%r12), %xmm1
movapd %xmm2, -0x70(%rbp)
mulsd %xmm2, %xmm1
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xba04
movq %r15, %rdi
callq 0xbdf6
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0xe4c8
movsd -0x38(%rbp), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
callq 0x8a24
movapd -0x70(%rbp), %xmm2
xorpd 0x32d1(%rip), %xmm2     # 0xf1c0
incq %r14
movl (%rbx), %eax
addq $0x10, %r12
jmp 0xbe5a
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x331d(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x8096(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x8a24
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getdDeterminant()
double Matrix::getdDeterminant()
{
    //valid only when rows=columns.
if (nRows != nColumns)
    throw("Invalid matrix dimension");
if (nRows == 1 && nColumns == 1)return values[0][0];
double value = 0;
double m = 1.0;
for (int iR = 0;iR<nRows;iR++)
{
    value += m * values[0][iR] * getCofactor(0, iR).getdDeterminant();
    m *= -1;
}
return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0xc019
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0xbf84
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
jmp 0xc00e
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x31c4(%rip), %xmm0     # 0xf158
xorl %r14d, %r14d
leaq -0x78(%rbp), %r15
cltq
cmpq %rax, %r14
jge 0xc009
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax,%r14,8), %xmm1
movsd %xmm1, -0x28(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r14d, %ecx
movapd %xmm0, -0x40(%rbp)
callq 0xba04
movq %r15, %rdi
callq 0xbf54
movsd -0x28(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq %r15, %rdi
callq 0x8a24
movapd -0x40(%rbp), %xmm0
xorpd 0x31be(%rip), %xmm0     # 0xf1c0
incq %r14
movl (%rbx), %eax
jmp 0xbf9b
movsd -0x20(%rbp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x321d(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x7f96(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x8a24
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: LUPDeterminant(std::complex<double>**, int*, int)
complex<double> LUPDeterminant(complex<double> **A, int *P, int N) {

    complex<double> det = A[0][0];

    for (int i = 1; i < N; i++)
        det *= A[i][i];

    if ((P[N] - N) % 2 == 0)
        return det;
    else
        return -det;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movq (%rdi), %rax
movups (%rax), %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, (%r15)
movslq %edx, %r12
pushq $0x1
popq %r13
pushq $0x10
popq %rbx
cmpq %r12, %r13
jge 0xc23f
movq (%r14,%r13,8), %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0xe4f4
incq %r13
addq $0x10, %rbx
jmp 0xc222
movq -0x30(%rbp), %rax
movl (%rax,%r12,4), %eax
subl %r12d, %eax
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
testb $0x1, %al
je 0xc265
movaps 0x2f61(%rip), %xmm2     # 0xf1c0
xorps %xmm2, %xmm0
xorps %xmm2, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::rdivide(double, Matrix const&)
Matrix Matrix::rdivide(double d, const Matrix& m)
{
	if(m.type=="complex")
	{
		Matrix result("complex",m.nRows,m.nColumns);
    for (int i=0; i<m.nRows; i++)
    {
        for (int j=0; j<m.nColumns; j++)
            result.cvalues[i][j] = ( d / m.cvalues[i][j] );
		}
		return result;
	}
	else if(m.type!="complex")
	{
		Matrix result(m.nRows,m.nColumns);
		for (int i=0; i<m.nRows; i++)
		{
				for (int j=0; j<m.nColumns; j++)
						result.values[i][j] = ( d / m.values[i][j] );
		}
		return result;
	 }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movsd %xmm0, -0x38(%rbp)
movsd %xmm0, -0x40(%rbp)
leaq 0x18(%rdx), %r15
leaq 0x2f55(%rip), %rsi      # 0xf1f5
movq %r15, %rdi
callq 0x795a
testb %al, %al
je 0xc345
leaq 0x2f3e(%rip), %rsi      # 0xf1f5
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x60(%rbp), %rsi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x60(%rbp), %rdi
callq 0x3170
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0xc3ba
movq %rbx, %r15
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0x4(%r14), %rax
cmpq %rax, %rbx
jge 0xc33d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rsi
addq %r13, %rsi
leaq -0x40(%rbp), %rdi
callq 0xe5ab
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13)
movsd %xmm1, 0x8(%rax,%r13)
incq %rbx
addq $0x10, %r13
jmp 0xc302
incq %r12
movq %r15, %rbx
jmp 0xc2ee
leaq 0x2ea9(%rip), %rsi      # 0xf1f5
movq %r15, %rdi
callq 0x78c0
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movl 0x4(%r14), %eax
testl %eax, %eax
cmovlel %r15d, %eax
movl (%r14), %ecx
testl %ecx, %ecx
cmovlel %r15d, %ecx
movsd -0x38(%rbp), %xmm1
cmpq %rcx, %r15
je 0xc3ba
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
cmpq %rdi, %rax
je 0xc3b5
movq (%rdx,%r15,8), %r8
movapd %xmm1, %xmm0
divsd (%r8,%rdi,8), %xmm0
movq (%rsi,%r15,8), %r8
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0xc393
incq %r15
jmp 0xc384
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0xc3ea
movq %rax, %r14
jmp 0xc3ea
movq %rax, %r14
movq %r15, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: operator>>(std::istream&, Matrix&)
istream& operator >> (istream &is, Matrix& m) //inputs the matrix through "cin>>" example: Matrix myMatrix; cin>>myMatrix;
{
	string s;
	getline(is, s, ']'); //] is the delimiter at which the getline knows this is the end of the string
	s += "]"; //because it wasn't saved in the actual string and the constructor uses it
	m = Matrix( s); //uses the constructor which takes an input string
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x30(%rbp), %rsi
pushq $0x5d
popq %rdx
callq 0x3560
leaq 0x2a46(%rip), %rsi      # 0xf203
leaq -0x30(%rbp), %rdi
callq 0x3590
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3410
leaq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8fdc
leaq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movq %r14, %rsi
callq 0x9e42
leaq -0xc0(%rbp), %rdi
callq 0x8a24
leaq -0x88(%rbp), %rdi
callq 0x8a24
leaq -0x50(%rbp), %rdi
callq 0x3170
leaq -0x30(%rbp), %rdi
callq 0x3170
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x8a24
jmp 0xc846
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xc856
jmp 0xc853
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getTranspose()
Matrix Matrix::getTranspose() {
    if(this->type=="complex")
    {
    Matrix x("complex",nColumns, nRows);
	for (int ir = 0; ir<x.nRows;ir++) {
		for (int ic = 0; ic<x.nColumns;ic++) {
			x.cvalues[ir][ic] = cvalues[ic][ir];
		}
	}
	return x;
    }
    else
    {
	Matrix x(nColumns, nRows);
	for (int ir = 0; ir<x.nRows;ir++) {
		for (int ic = 0; ic<x.nColumns;ic++) {
			x.values[ir][ic] = values[ic][ir];
		}
	}
	return x;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x2921(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xc965
leaq 0x290d(%rip), %rsi      # 0xf1f5
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x7844
movl (%r14), %ecx
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x40(%rbp), %rdi
callq 0x3170
xorl %eax, %eax
movslq (%rbx), %rcx
cmpq %rcx, %rax
jge 0xc9bf
movq %rax, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
xorl %esi, %esi
movslq 0x4(%rbx), %rdi
cmpq %rdi, %rsi
jge 0xc960
movq 0x10(%r14), %rdi
movq (%rdi,%rsi,8), %rdi
movq 0x10(%rbx), %r8
movq (%r8,%rax,8), %r8
movups (%rdi,%rcx), %xmm0
movups %xmm0, (%r8,%rdx)
incq %rsi
addq $0x10, %rdx
jmp 0xc935
incq %rax
jmp 0xc91e
movl (%r14), %edx
movl 0x4(%r14), %esi
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movl 0x4(%rbx), %eax
testl %eax, %eax
cmovlel %r15d, %eax
movl (%rbx), %ecx
testl %ecx, %ecx
cmovlel %r15d, %ecx
cmpq %rcx, %r15
je 0xc9bf
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
cmpq %rdi, %rax
je 0xc9ba
movq (%rdx,%rdi,8), %r8
movsd (%r8,%r15,8), %xmm0
movq (%rsi,%r15,8), %r8
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0xc99c
incq %r15
jmp 0xc98d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::sin(Matrix&)
Matrix Matrix::sin(Matrix&s)
{
    if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::sin(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::sin(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x27f1(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xca9b
leaq 0x27dd(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcaf1
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xca96
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe608
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xca5f
incq %r15
jmp 0xca4d
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcaf1
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xcaec
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3080
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcabd
incq %r15
jmp 0xcab2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xcb21
movq %rax, %r14
jmp 0xcb21
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::cos(Matrix&)
Matrix Matrix::cos(Matrix&s)
{
    if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::cos(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::cos(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x26a9(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xcbe3
leaq 0x2695(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcc39
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xcbde
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe61b
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xcba7
incq %r15
jmp 0xcb95
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcc39
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xcc34
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3580
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcc05
incq %r15
jmp 0xcbfa
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xcc69
movq %rax, %r14
jmp 0xcc69
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::tan(Matrix&)
Matrix Matrix::tan(Matrix&s)
{
    if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::tan(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::tan(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x2561(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xcd2b
leaq 0x254d(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcd81
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xcd26
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe62e
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xccef
incq %r15
jmp 0xccdd
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcd81
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xcd7c
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3220
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcd4d
incq %r15
jmp 0xcd42
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xcdb1
movq %rax, %r14
jmp 0xcdb1
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::acos(Matrix&)
Matrix Matrix::acos(Matrix&s)
{
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::acos(s.values[iR][iC]);
		}
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xce1d
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xce18
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3320
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcde9
incq %r15
jmp 0xcdde
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::asin(Matrix&)
Matrix Matrix::asin(Matrix&s)
{
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::asin(s.values[iR][iC]);
		}
    }
    return m;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xce8d
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xce88
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x34b0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xce59
incq %r15
jmp 0xce4e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::atan(Matrix&)
Matrix Matrix::atan(Matrix&s)
{    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::atan(s.values[iR][iC]);
		}
    }
    return m;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xcefd
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xcef8
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x32b0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcec9
incq %r15
jmp 0xcebe
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::sinh(Matrix&)
Matrix Matrix::sinh(Matrix&s)
{
    if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::sinh(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::sinh(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x22c9(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xcfc3
leaq 0x22b5(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd019
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xcfbe
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe641
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xcf87
incq %r15
jmp 0xcf75
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd019
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd014
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3300
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xcfe5
incq %r15
jmp 0xcfda
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xd049
movq %rax, %r14
jmp 0xd049
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::cosh(Matrix&)
Matrix Matrix::cosh(Matrix&s)
{if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::cosh(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::cosh(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x2181(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xd10b
leaq 0x216d(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd161
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xd106
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe654
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xd0cf
incq %r15
jmp 0xd0bd
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd161
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd15c
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3430
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd12d
incq %r15
jmp 0xd122
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xd191
movq %rax, %r14
jmp 0xd191
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::tanh(Matrix&)
Matrix Matrix::tanh(Matrix&s)
{
    if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::tanh(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::tanh(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x2039(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xd253
leaq 0x2025(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd2a9
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xd24e
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe667
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xd217
incq %r15
jmp 0xd205
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd2a9
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd2a4
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x30a0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd275
incq %r15
jmp 0xd26a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xd2d9
movq %rax, %r14
jmp 0xd2d9
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::a_sinh(Matrix&)
Matrix Matrix::a_sinh(Matrix&s)
{
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=asinh(s.values[iR][iC]);
		}
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd345
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd340
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3400
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd311
incq %r15
jmp 0xd306
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::a_cosh(Matrix&)
Matrix Matrix::a_cosh(Matrix&s)
{   Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=acosh(s.values[iR][iC]);
		}
    }
    return m;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd3b5
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd3b0
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3500
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd381
incq %r15
jmp 0xd376
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::a_tanh(Matrix&)
Matrix Matrix::a_tanh(Matrix&s)
{   Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=atanh(s.values[iR][iC]);
		}
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd425
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd420
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3510
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd3f1
incq %r15
jmp 0xd3e6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::log(Matrix&)
Matrix Matrix::log(Matrix&s)
{if(s.type=="complex")
    {
Matrix m("complex",s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.cvalues[iR][iC]=std::log(s.cvalues[iR][iC]);
		}
    }
    return m;
    }
    else
    {
    Matrix m(s.nRows,s.nColumns);
    for (int iR = 0;iR<m.nRows;iR++)
    {
		for (int iC = 0;iC<m.nColumns;iC++)
		{
            m.values[iR][iC]=std::log(s.values[iR][iC]);
		}
    }
    return m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x1da1(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xd4eb
leaq 0x1d8d(%rip), %rsi      # 0xf1f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq -0x50(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xe29a
leaq -0x50(%rbp), %rdi
callq 0x3170
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd541
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0xd4e6
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0xe67a
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12)
movsd %xmm1, 0x8(%rax,%r12)
incq %r13
addq $0x10, %r12
jmp 0xd4af
incq %r15
jmp 0xd49d
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8ace
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0xd541
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xd53c
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3290
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0xd50d
incq %r15
jmp 0xd502
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0xd571
movq %rax, %r14
jmp 0xd571
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a24
movq %r14, %rdi
callq 0x3520
nop