LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getAltStringNoB[abi:cxx11]()
string Matrix::getAltStringNoB()
{
    string s="";
    for (int iR=0;iR<nRows;iR++)
    {
        for (int iC=0;iC<nColumns;iC++)
        {
            char buffer[50]="";
            if(iC<nColumns-1)
            snprintf(buffer,50,"%g ", values[iR][iC]);
            else
                 snprintf(buffer,50,"%g", values[iR][iC]);
            s+= buffer;
        }
        if(iR < nRows-1)
        s+= ';';
//        else
//        s+=']';
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x5af9(%rip), %rdx      # 0x11222
movq %rdx, %rsi
callq 0x9334
cmpl $0x0, (%r14)
jle 0xb7d6
xorl %r13d, %r13d
leaq -0x70(%rbp), %r15
movl 0x4(%r14), %eax
testl %eax, %eax
jle 0xb7af
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
decl %eax
cltq
cmpq %rax, %r12
leaq 0x5ad8(%rip), %rdx      # 0x11242
leaq 0x5acd(%rip), %rax      # 0x1123e
cmovlq %rax, %rdx
movw $0x0, -0x40(%rbp)
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
movl $0x32, %esi
movq %r15, %rdi
movb $0x1, %al
callq 0x3470
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3590
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xb74d
movslq (%r14), %rax
decq %rax
cmpq %rax, %r13
jge 0xb7c7
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x3280
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0xb742
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb7ea
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xb804
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x4ad8(%rip), %rcx      # 0x111f5
movl $0x7, %r8d
xorl %esi, %esi
callq 0x3450
cmpl $0x0, (%rbx)
jle 0xc770
xorl %r15d, %r15d
leaq -0x38(%rbp), %r14
cmpl $0x0, 0x4(%rbx)
jle 0xc765
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x10788
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xc742
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xc736
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa4f6
movq %rbx, %rdi
callq 0xa052
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %r14, %rdx
callq 0xc8c2
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xa54e
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
callq 0xa4f6
leaq -0xb8(%rbp), %rdi
callq 0xa0be
leaq -0x48(%rbp), %rdi
callq 0xa0be
leaq -0x80(%rbp), %rdi
callq 0xa0be
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0xc8a9
movq %rax, %r14
jmp 0xc8b1
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0xa0be
movq %rbx, %rdi
callq 0xa0be
leaq -0x80(%rbp), %rdi
callq 0xa0be
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa4f6
movl 0x4(%r15), %eax
cmpl (%r14), %eax
jne 0xc95f
leaq -0x50(%rbp), %rdi
callq 0xa052
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0xcac0
leaq -0x50(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa54e
leaq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa4f6
leaq -0xc0(%rbp), %rdi
callq 0xa0be
leaq -0x88(%rbp), %rdi
callq 0xa0be
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xc0c6
leaq -0x50(%rbp), %rdi
callq 0xa0be
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3170
leaq 0x491a(%rip), %rcx      # 0x1128a
movq %rcx, (%rax)
movq 0x9646(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
jmp 0xc986
movq %rax, %r14
jmp 0xc9a1
jmp 0xc98d
movq %rax, %r14
jmp 0xc9aa
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0xa0be
leaq -0x50(%rbp), %rdi
callq 0xa0be
movq %rbx, %rdi
callq 0xa0be
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa4f6
movsd -0x10(%rbp), %xmm1
movslq (%rbx), %rax
testq %rax, %rax
jle 0xca0e
movl 0x4(%rbx), %ecx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
jle 0xca06
movq (%rdx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0xc9ee
incq %rsi
cmpq %rax, %rsi
jne 0xc9e3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq (%rsi), %rax
testq %rax, %rax
jle 0xd238
movl 0x4(%rsi), %ecx
movq 0x8(%rsi), %rdx
xorl %edi, %edi
movaps 0x3fb1(%rip), %xmm0     # 0x111c0
testl %ecx, %ecx
jle 0xd230
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0xd21a
incq %rdi
cmpq %rax, %rdi
jne 0xd20f
movq %rbx, %rdi
callq 0xa4f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %edx, -0x2c(%rbp)
testl %edx, %edx
jg 0xd657
movl %ecx, %r12d
testl %ecx, %ecx
jg 0xd657
movl %r9d, %r13d
movl %r8d, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x3cdb(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xd592
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl %r15d, %esi
movl %r13d, %edx
xorl %ecx, %ecx
callq 0xa1a2
movslq (%rbx), %rax
testq %rax, %rax
jle 0xd645
movl 0x4(%rbx), %ecx
movq 0x8(%rbx), %rdx
movslq %r12d, %rsi
movslq -0x2c(%rbp), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
xorl %r8d, %r8d
shlq $0x3, %rsi
testl %ecx, %ecx
jle 0xd585
movq (%rdx,%r8,8), %r9
movq (%rdi,%r8,8), %r10
addq %rsi, %r10
xorl %r11d, %r11d
movsd (%r10,%r11,8), %xmm0
movsd %xmm0, (%r9,%r11,8)
incq %r11
cmpq %r11, %rcx
jne 0xd571
incq %r8
cmpq %rax, %r8
jne 0xd55f
jmp 0xd645
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3c54(%rip), %rsi      # 0x111f5
leaq 0x3c54(%rip), %rdx      # 0x111fc
leaq -0x50(%rbp), %rdi
callq 0x9334
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
movl %r15d, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x10518
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xd5e5
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xd645
movslq %r12d, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rax
xorl %edx, %edx
cmpl $0x0, 0x4(%rbx)
jle 0xd63a
leaq (,%rdx,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
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
movslq 0x4(%rbx), %r9
addq $0x10, %rdi
cmpq %r9, %r8
jl 0xd60a
incq %rdx
movslq (%rbx), %rsi
cmpq %rsi, %rdx
jl 0xd5f7
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3170
leaq 0x3bdd(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x894e(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xd698
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x3030
movq %rax, %rbx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa4f6
movq 0x8(%r15), %rdi
movl (%r14), %esi
movsd 0x388a(%rip), %xmm0     # 0x11170
movq %rbx, %rdx
callq 0xd96d
movq 0x8(%r15), %rcx
movslq (%r14), %rax
movq (%rcx), %rdx
movsd (%rdx), %xmm0
cmpq $0x2, %rax
jl 0xd918
movl $0x1, %edx
movq (%rcx,%rdx,8), %rsi
mulsd (%rsi,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xd907
movl (%rbx,%rax,4), %ecx
subl %eax, %ecx
testb $0x1, %cl
je 0xd92a
xorpd 0x3896(%rip), %xmm0     # 0x111c0
xorpd %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0x3838(%rip), %xmm2     # 0x11178
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
movapd %xmm2, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa0be
movaps -0x30(%rbp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
js 0xd981
leal 0x1(%rsi), %eax
xorl %ecx, %ecx
movl %ecx, (%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xd976
movl $0x1, %eax
testl %esi, %esi
jle 0xda78
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ecx
movl $0x1, %esi
xorl %r9d, %r9d
movapd 0x3839(%rip), %xmm1     # 0x111e0
movq %r9, %r8
xorpd %xmm2, %xmm2
movq %r9, %r10
movapd %xmm2, %xmm3
movq (%rdi,%r10,8), %r11
movsd (%r11,%r8,8), %xmm2
andpd %xmm1, %xmm2
ucomisd %xmm3, %xmm2
cmoval %r10d, %r9d
maxsd %xmm3, %xmm2
incq %r10
cmpq %r10, %rcx
jne 0xd9b1
ucomisd %xmm2, %xmm0
ja 0xda72
movl %r9d, %r10d
cmpq %r10, %r8
je 0xda0f
movl (%rdx,%r8,4), %r10d
movslq %r9d, %r9
movl (%rdx,%r9,4), %r11d
movl %r11d, (%rdx,%r8,4)
movl %r10d, (%rdx,%r9,4)
movq (%rdi,%r8,8), %r10
movq (%rdi,%r9,8), %r11
movq %r11, (%rdi,%r8,8)
movq %r10, (%rdi,%r9,8)
incl (%rdx,%rcx,4)
leaq 0x1(%r8), %r9
cmpq %rcx, %r9
jae 0xda64
movq (%rdi,%r8,8), %r10
movq %rsi, %r11
movq (%rdi,%r11,8), %rbx
movsd (%rbx,%r8,8), %xmm2
divsd (%r10,%r8,8), %xmm2
movsd %xmm2, (%rbx,%r8,8)
movq %rsi, %r14
movsd (%rbx,%r8,8), %xmm2
movsd (%rbx,%r14,8), %xmm3
mulsd (%r10,%r14,8), %xmm2
subsd %xmm2, %xmm3
movsd %xmm3, (%rbx,%r14,8)
incq %r14
cmpq %r14, %rcx
jne 0xda38
incq %r11
cmpq %rcx, %r11
jne 0xda1f
incq %rsi
cmpq %rcx, %r9
jne 0xd9a7
jmp 0xda74
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x2, %edx
jl 0xdaa2
movl %edx, %eax
movl $0x1, %ecx
movq (%rdi,%rcx,8), %r8
mulsd (%r8,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xda90
movslq %edx, %rax
movl (%rsi,%rax,4), %eax
subl %edx, %eax
testb $0x1, %al
je 0xdab6
xorpd 0x370a(%rip), %xmm0     # 0x111c0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x98, %rsp
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
cmpl %ecx, %eax
jne 0xdc16
movq %rdi, %rbx
xorl $0x1, %eax
xorl $0x1, %ecx
orl %eax, %ecx
jne 0xdb00
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%rax), %xmm0
jmp 0xdbf5
cmpl $0x0, (%rbx)
jle 0xdbed
movsd 0x3647(%rip), %xmm0     # 0x11158
movaps %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x8, %r12d
xorl %r14d, %r14d
leaq -0xb8(%rbp), %r15
leaq -0x80(%rbp), %r13
movsd %xmm0, -0x30(%rbp)
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd (%rax,%r12), %xmm0
movsd %xmm0, -0x70(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xd6a0
movq %r15, %rdi
callq 0xdab8
movapd -0x60(%rbp), %xmm4
movsd -0x70(%rbp), %xmm2
mulsd %xmm4, %xmm2
movsd -0x68(%rbp), %xmm3
mulsd %xmm4, %xmm3
movsd %xmm0, -0x80(%rbp)
movsd %xmm1, -0x78(%rbp)
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x10788
movsd -0x30(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %r15, %rdi
callq 0xa0be
movaps -0x60(%rbp), %xmm0
xorps 0x35ec(%rip), %xmm0     # 0x111c0
movaps %xmm0, -0x60(%rbp)
incq %r14
movslq (%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r14
jl 0xdb36
jmp 0xdbfa
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3170
leaq 0x361e(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x838f(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0xa0be
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
cmpl %ecx, %eax
jne 0xdd2f
movq %rdi, %rbx
xorl $0x1, %eax
xorl $0x1, %ecx
orl %eax, %ecx
jne 0xdc89
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
jmp 0xdd1a
cmpl $0x0, (%rbx)
jle 0xdd17
movsd 0x34be(%rip), %xmm0     # 0x11158
movaps %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorl %r14d, %r14d
leaq -0x70(%rbp), %r15
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xd6a0
movq %r15, %rdi
callq 0xdc52
movsd -0x38(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq %r15, %rdi
callq 0xa0be
movaps -0x30(%rbp), %xmm0
xorps 0x34ba(%rip), %xmm0     # 0x111c0
movaps %xmm0, -0x30(%rbp)
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xdcad
jmp 0xdd1f
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3170
leaq 0x3505(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x8276(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa0be
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %edx, %ebx
movq %rsi, -0x48(%rbp)
movq (%rdi), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
cmpl $0x2, %edx
jl 0xdf9d
movq %rdi, %r15
movl %ebx, %r13d
addq $0x8, %r15
shlq $0x4, %r13
movl $0x10, %r14d
leaq -0x40(%rbp), %r12
movq (%r15), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x10788
addq $0x10, %r14
addq $0x8, %r15
cmpq %r14, %r13
jne 0xdf82
movslq %ebx, %rax
movq -0x48(%rbp), %rcx
movl (%rcx,%rax,4), %eax
subl %ebx, %eax
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
testb $0x1, %al
je 0xdfc4
movaps 0x3202(%rip), %xmm2     # 0x111c0
xorps %xmm2, %xmm0
xorps %xmm2, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %r14
movsd %xmm0, -0x30(%rbp)
movq %rdi, %rbx
leaq 0x18(%rdx), %r15
leaq 0x31fa(%rip), %rsi      # 0x111f5
movq %r15, %rdi
callq 0x30e0
testl %eax, %eax
je 0xe07e
leaq 0x31e7(%rip), %rsi      # 0x111f5
movq %r15, %rdi
callq 0x30e0
movl (%r14), %esi
movl 0x4(%r14), %edx
xorpd %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
movslq (%r14), %rax
testq %rax, %rax
movsd -0x30(%rbp), %xmm1
jle 0xe148
movl 0x4(%r14), %ecx
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0xe071
movq (%rdx,%rdi,8), %r8
movq (%rsi,%rdi,8), %r9
xorl %r10d, %r10d
movapd %xmm1, %xmm0
divsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0xe059
incq %rdi
cmpq %rax, %rdi
jne 0xe04a
jmp 0xe148
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3167(%rip), %rsi      # 0x111f5
leaq 0x3167(%rip), %rdx      # 0x111fc
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xe0d3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%r14)
movsd -0x30(%rbp), %xmm4
jle 0xe148
xorl %r15d, %r15d
cmpl $0x0, 0x4(%r14)
jle 0xe13d
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm2
movsd (%rax,%r12), %xmm3
xorpd %xmm1, %xmm1
movapd %xmm4, %xmm0
callq 0x31f0
movsd -0x30(%rbp), %xmm4
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xe0f1
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0xe0e1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xe172
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x40(%rbp), %rsi
movl $0x5d, %edx
callq 0x3560
leaq 0x2c29(%rip), %rsi      # 0x11203
leaq -0x40(%rbp), %rdi
callq 0x3590
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x929a
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa768
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0xa54e
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
callq 0xa4f6
leaq -0xd0(%rbp), %rdi
callq 0xa0be
leaq -0x98(%rbp), %rdi
callq 0xa0be
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe65b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3300
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe670
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe699
jmp 0xe6b0
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xa0be
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe6b3
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3300
jmp 0xe6b3
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe6c8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x2a93(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xe7c8
movl (%r14), %edx
movl 0x4(%r14), %esi
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
movslq (%rbx), %rax
testq %rax, %rax
jle 0xe867
movl 0x4(%rbx), %ecx
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0xe7bb
movq (%rsi,%rdi,8), %r8
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0xe7a3
incq %rdi
cmpq %rax, %rdi
jne 0xe798
jmp 0xe867
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2a1d(%rip), %rsi      # 0x111f5
leaq 0x2a1d(%rip), %rdx      # 0x111fc
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %ecx
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe81b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xe867
xorl %eax, %eax
cmpl $0x0, 0x4(%rbx)
jle 0xe85c
movq %rax, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
xorl %esi, %esi
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
movslq 0x4(%rbx), %rdi
addq $0x10, %rdx
cmpq %rdi, %rsi
jl 0xe833
incq %rax
movslq (%rbx), %rcx
cmpq %rcx, %rax
jl 0xe822
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe88f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x293b(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xe929
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xe9dd
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xe919
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xe8ec
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xe8e3
jmp 0xe9dd
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x28bc(%rip), %rsi      # 0x111f5
leaq 0x28bc(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xe97c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xe9dd
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xe9d2
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x3200
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xe993
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xe984
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xea07
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27c3(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xeaa1
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xeb55
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xea91
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xea64
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xea5b
jmp 0xeb55
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2744(%rip), %rsi      # 0x111f5
leaq 0x2744(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xeaf4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xeb55
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xeb4a
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x3050
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xeb0b
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xeafc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xeb7f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x264b(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xec19
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xeccd
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xec09
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x31e0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xebdc
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xebd3
jmp 0xeccd
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x25cc(%rip), %rsi      # 0x111f5
leaq 0x25cc(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xec6c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xeccd
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xecc2
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x33e0
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xec83
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xec74
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xecf7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xed6a
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xed5f
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x32c0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xed32
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xed29
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xede0
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xedd5
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x34a0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xeda8
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xed9f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xee56
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xee4b
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x3270
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xee1e
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xee15
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2371(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xeef3
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xefa7
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xeee3
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xeeb6
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xeead
jmp 0xefa7
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x22f2(%rip), %rsi      # 0x111f5
leaq 0x22f2(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xef46
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xefa7
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xef9c
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x3430
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xef5d
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xef4e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xefd1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21f9(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xf06b
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xf11f
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf05b
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x33f0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf02e
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf025
jmp 0xf11f
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x217a(%rip), %rsi      # 0x111f5
leaq 0x217a(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xf0be
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xf11f
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf114
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x3380
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xf0d5
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf0c6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xf149
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2081(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xf1e3
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xf297
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf1d3
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf1a6
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf19d
jmp 0xf297
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2002(%rip), %rsi      # 0x111f5
leaq 0x2002(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9334
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x10518
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xf236
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
cmpl $0x0, (%rbx)
jle 0xf297
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf28c
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
callq 0x3110
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, -0x8(%rax,%r12)
movsd %xmm1, (%rax,%r12)
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xf24d
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf23e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xf2c1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xf334
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf329
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x33d0
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf2fc
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf2f3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xf3aa
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf39f
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf372
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf369
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0xa1a2
cmpl $0x0, (%rbx)
jle 0xf420
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xf415
xorl %r12d, %r12d
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
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf3e8
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0xf3df
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq