LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(int, int, double, ...)
Matrix::Matrix(int nRows, int nColumns, double first, ...)
{
	this->nRows = nRows;
	this->nColumns = nColumns;
	if ((nRows*nColumns) == 0)
	{
		values = NULL;
		return;
	}
	values = new double*[nRows];
	va_list va;
	va_start(va, first);
	for (int iR = 0;iR<nRows;iR++)
	{
		values[iR] = new double[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			values[iR][iC] = (iC == 0 && iR == 0) ? first : va_arg(va, double);
		}
	}
	va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movsd %xmm0, -0x60(%rbp)
movl %edx, %r14d
movq %rdi, %rbx
movq %rcx, -0xf8(%rbp)
movq %r8, -0xf0(%rbp)
movq %r9, -0xe8(%rbp)
testb %al, %al
je 0xa463
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
leaq 0x28(%rdi), %rdx
movq %rdx, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl %esi, (%rdi)
movl %r14d, 0x4(%rdi)
testl %esi, %esi
setne %al
testl %r14d, %r14d
setne %cl
testb %al, %cl
je 0xa568
movl %esi, %r15d
movq %rdx, -0x30(%rbp)
movl %esi, %eax
movq %rax, -0x58(%rbp)
leaq (,%rax,8), %rdi
testl %esi, %esi
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
leaq -0x110(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x4000000018, %rax     # imm = 0x4000000018
movq %rax, -0x50(%rbp)
testl %r15d, %r15d
jle 0xa570
movl %r14d, %r12d
leaq (,%r12,8), %r15
testl %r14d, %r14d
cmovsq %r13, %r15
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
testl %r14d, %r14d
jle 0xa55d
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, %edx
orl %r13d, %edx
movsd -0x60(%rbp), %xmm0
je 0xa54c
movl -0x4c(%rbp), %esi
cmpq $0xa0, %rsi
ja 0xa53c
movq %rsi, %rdx
addq -0x40(%rbp), %rdx
addl $0x10, %esi
movl %esi, -0x4c(%rbp)
jmp 0xa548
movq -0x48(%rbp), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, -0x48(%rbp)
movsd (%rdx), %xmm0
movq (%rax,%r13,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0xa515
incq %r13
cmpq -0x58(%rbp), %r13
jne 0xa4fa
jmp 0xa570
movq $0x0, 0x8(%rbx)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xa59e
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::copy(Matrix const&)
void Matrix::copy(const Matrix& m)
{
	reset();
	this->nRows = m.nRows;
	this->nColumns = m.nColumns;
	if ((nRows*nColumns) == 0)
	{
		values = NULL;
		cvalues=NULL;
		return;
	}
   if(m.type=="complex")
   {
     type="complex";
	 cvalues = new complex<double>*[nRows];
	 for (int iR = 0;iR<nRows;iR++)
	 {
		cvalues[iR] = new complex<double>[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			cvalues[iR][iC] = m.cvalues[iR][iC];
		}
	 }
	}
   else
    {
	 values = new double*[nRows];
	 for (int iR = 0;iR<nRows;iR++)
	 {
		values[iR] = new double[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			values[iR][iC] = m.values[iR][iC];
		}
	 }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa1ba
movl (%r14), %eax
movl %eax, (%rbx)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rbx)
testl %eax, %eax
setne %al
testl %ecx, %ecx
setne %cl
testb %al, %cl
je 0xa6e2
movq %r14, -0x38(%rbp)
leaq 0x18(%r14), %rdi
leaq 0x6bae(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xa6ee
movslq (%rbx), %r14
leaq (,%r14,8), %rdi
testq %r14, %r14
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
testq %r14, %r14
jle 0xa7d5
movslq 0x4(%rbx), %rax
leaq (,%rax,8), %r15
testq %rax, %rax
cmovsq %r12, %r15
movl %eax, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
testl %r12d, %r12d
jle 0xa6d5
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0xa6c3
incq %r13
cmpq %r14, %r13
jne 0xa698
jmp 0xa7d5
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0xa7d5
leaq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
leaq 0x6af8(%rip), %rcx      # 0x111f5
movl $0x7, %r8d
xorl %esi, %esi
callq 0x3450
movslq (%rbx), %r14
leaq (,%r14,8), %rdi
testq %r14, %r14
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
movq %r14, -0x30(%rbp)
testq %r14, %r14
jle 0xa7d5
movl 0x4(%rbx), %r14d
xorl %r13d, %r13d
movslq %r14d, %r15
movq %r15, %r12
shlq $0x4, %r12
testl %r15d, %r15d
movq %r12, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x3030
testl %r15d, %r15d
je 0xa7ba
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x31d0
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r13,8)
testl %r14d, %r14d
jle 0xa7c5
xorl %eax, %eax
xorl %ecx, %ecx
movq -0x38(%rbp), %rdi
movq 0x10(%rdi), %rdx
movq (%rdx,%r13,8), %rdx
movq 0x10(%rbx), %rsi
movq (%rsi,%r13,8), %rsi
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rsi,%rax)
incq %rcx
movslq 0x4(%rbx), %r14
addq $0x10, %rax
cmpq %r14, %rcx
jl 0xa78a
movl (%rbx), %eax
movq %rax, -0x30(%rbp)
jmp 0xa7c5
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
xorl %r14d, %r14d
incq %r13
movslq -0x30(%rbp), %rax
cmpq %rax, %r13
jl 0xa740
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Matrix::Matrix(string s)
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues = NULL;
	copy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq -0x30(%rbp), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x934c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xa8f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa8aa
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa8d4
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
jmp 0xa8d4
movq %rax, %r14
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xa8e8
movq (%r15), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(double)
Matrix::Matrix(double d)
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues = NULL;
	copy(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
callq 0xad7e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xad76
movq (%r15), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::copy(double)
void Matrix::copy(double d)
{
	this->nRows = 1;
	this->nColumns = 1;
	if (this->type=="complex")
    {
    cvalues = new complex<double>*[1];
	cvalues[0] = new complex<double>[1];
	cvalues[0][0] = d;
    }
    else{
	values = new double*[1];
	values[0] = new double[1];
	values[0][0] = d;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x644d(%rip), %rsi      # 0x111f5
callq 0x30e0
movl %eax, %r15d
movl $0x8, %edi
callq 0x3030
movq %rax, %r14
testl %r15d, %r15d
je 0xadde
movq %r14, 0x8(%rbx)
movl $0x8, %edi
callq 0x3030
movq %rax, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xae00
movq %r14, 0x10(%rbx)
movl $0x10, %edi
callq 0x3030
movq %rax, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::addColumn(Matrix&)
void Matrix::addColumn(Matrix& m)
{   if(m.type=="complex")
    {
    Matrix n("complex",max(nRows, m.nRows), nColumns + m.nColumns);
    n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(0, nColumns, m);
	*this = n;
    }
    else
    {
	Matrix n(max(nRows, m.nRows), nColumns + m.nColumns);
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(0, nColumns, m);
	*this = n;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x605c(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xb20b
movl (%rbx), %eax
movl (%r14), %esi
movl 0x4(%r14), %edx
cmpl %esi, %eax
cmovgl %eax, %esi
addl 0x4(%rbx), %edx
leaq -0x70(%rbp), %r15
xorps %xmm0, %xmm0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xa262
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd364
movl 0x4(%rbx), %edx
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xd364
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5fe
leaq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0xa5a6
leaq -0xa8(%rbp), %rdi
jmp 0xb2a9
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5fdb(%rip), %rsi      # 0x111f5
leaq 0x5fdb(%rip), %rdx      # 0x111fc
leaq -0x38(%rbp), %rdi
callq 0x93ea
movl (%rbx), %eax
movl (%r14), %edx
movl 0x4(%r14), %ecx
cmpl %edx, %eax
cmovgl %eax, %edx
addl 0x4(%rbx), %ecx
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %r8d, %r8d
callq 0x106da
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb266
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3300
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd364
movl 0x4(%rbx), %edx
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xd364
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5fe
leaq -0xe0(%rbp), %rdi
movq %rbx, %rsi
callq 0xa5a6
leaq -0xe0(%rbp), %rdi
callq 0xa186
leaq -0x70(%rbp), %rdi
callq 0xa186
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb2f2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3300
jmp 0xb2f2
movq %rax, %rbx
jmp 0xb2f2
jmp 0xb2e6
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::addRow(Matrix&)
void Matrix::addRow(Matrix& m)
{
    if(m.type=="complex")
        {
	Matrix n("complex",nRows + m.nRows, max(nColumns, m.nColumns));
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(nRows, 0, m);
	*this = n;
        }
	else
      {
    Matrix n(nRows + m.nRows, max(nColumns, m.nColumns));
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(nRows, 0, m);
	*this = n;
      }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x5eda(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xb38c
movl (%r14), %esi
movl 0x4(%r14), %edx
addl (%rbx), %esi
movl 0x4(%rbx), %eax
cmpl %edx, %eax
cmovgl %eax, %edx
leaq -0x70(%rbp), %r15
xorps %xmm0, %xmm0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xa262
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd364
movl (%rbx), %esi
leaq -0x70(%rbp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xd364
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5fe
leaq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0xa5a6
leaq -0xa8(%rbp), %rdi
jmp 0xb429
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5e5a(%rip), %rsi      # 0x111f5
leaq 0x5e5a(%rip), %rdx      # 0x111fc
leaq -0x38(%rbp), %rdi
callq 0x93ea
movl (%r14), %edx
movl 0x4(%r14), %ecx
addl (%rbx), %edx
movl 0x4(%rbx), %eax
cmpl %ecx, %eax
cmovgl %eax, %ecx
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %r8d, %r8d
callq 0x106da
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb3e7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3300
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd364
movl (%rbx), %esi
leaq -0x70(%rbp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xd364
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5fe
leaq -0xe0(%rbp), %rdi
movq %rbx, %rsi
callq 0xa5a6
leaq -0xe0(%rbp), %rdi
callq 0xa186
leaq -0x70(%rbp), %rdi
callq 0xa186
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb472
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3300
jmp 0xb472
movq %rax, %rbx
jmp 0xb472
jmp 0xb466
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getAltString[abi:cxx11]()
string Matrix::getAltString()
{
    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 0x59c9(%rip), %rsi      # 0x110b6
leaq 0x59c3(%rip), %rdx      # 0x110b7
callq 0x93ea
movl (%r14), %eax
testl %eax, %eax
jle 0xb7a7
xorl %r13d, %r13d
leaq -0x70(%rbp), %r15
movl 0x4(%r14), %ecx
testl %ecx, %ecx
jle 0xb77c
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movw $0x0, -0x40(%rbp)
decl %ecx
movslq %ecx, %rax
cmpq %rax, %r12
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
leaq 0x5afa(%rip), %rdx      # 0x11242
leaq 0x5aef(%rip), %rax      # 0x1123e
cmovlq %rax, %rdx
movl $0x32, %esi
movq %r15, %rdi
movb $0x1, %al
callq 0x3470
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3590
incq %r12
movslq 0x4(%r14), %rcx
cmpq %rcx, %r12
jl 0xb716
movl (%r14), %eax
decl %eax
cltq
cmpq %rax, %r13
movl $0x5d, %esi
movl $0x3b, %eax
cmovll %eax, %esi
movq %rbx, %rdi
callq 0x3280
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0xb70b
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb7bb
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xb7d5
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5a1b(%rip), %rdx      # 0x11222
movq %rdx, %rsi
callq 0x93ea
movl (%r14), %eax
testl %eax, %eax
jle 0xb8bc
xorl %r13d, %r13d
leaq -0x70(%rbp), %r15
movl 0x4(%r14), %ecx
testl %ecx, %ecx
jle 0xb892
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movw $0x0, -0x40(%rbp)
decl %ecx
movslq %ecx, %rax
cmpq %rax, %r12
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
leaq 0x59e4(%rip), %rdx      # 0x11242
leaq 0x59d9(%rip), %rax      # 0x1123e
cmovlq %rax, %rdx
movl $0x32, %esi
movq %r15, %rdi
movb $0x1, %al
callq 0x3470
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3590
incq %r12
movslq 0x4(%r14), %rcx
cmpq %rcx, %r12
jl 0xb82c
movl (%r14), %eax
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0xb8ad
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x3280
movl (%r14), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0xb821
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb8d0
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xb8ea
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49e0(%rip), %rcx      # 0x111f5
movl $0x7, %r8d
xorl %esi, %esi
callq 0x3450
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xc86c
movl 0x4(%rbx), %eax
xorl %r15d, %r15d
leaq -0x38(%rbp), %r14
testl %eax, %eax
jle 0xc861
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x10952
incq %r13
movslq 0x4(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0xc83c
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xc832
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa5a6
movq %rbx, %rdi
callq 0xa11a
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %r14, %rdx
callq 0xc9be
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5fe
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
callq 0xa5a6
leaq -0xb8(%rbp), %rdi
callq 0xa186
leaq -0x48(%rbp), %rdi
callq 0xa186
leaq -0x80(%rbp), %rdi
callq 0xa186
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0xc9a5
movq %rax, %r14
jmp 0xc9ad
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0xa186
leaq -0x80(%rbp), %rdi
callq 0xa186
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa5a6
movl 0x4(%r15), %eax
cmpl (%r14), %eax
jne 0xca5b
leaq -0x50(%rbp), %rdi
callq 0xa11a
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0xcbbc
leaq -0x50(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa5fe
leaq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa5a6
leaq -0xc0(%rbp), %rdi
callq 0xa186
leaq -0x88(%rbp), %rdi
callq 0xa186
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xc1b6
leaq -0x50(%rbp), %rdi
callq 0xa186
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3170
leaq 0x481e(%rip), %rcx      # 0x1128a
movq %rcx, (%rax)
movq 0x954a(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
jmp 0xca82
movq %rax, %r14
jmp 0xca9d
jmp 0xca89
movq %rax, %r14
jmp 0xcaa6
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0xa186
leaq -0x50(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0xa186
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa5a6
movsd -0x10(%rbp), %xmm1
movslq (%rbx), %rax
testq %rax, %rax
jle 0xcb0a
movl 0x4(%rbx), %ecx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
jle 0xcb02
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 0xcaea
incq %rsi
cmpq %rax, %rsi
jne 0xcadf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd33a
movl 0x4(%rsi), %ecx
movq 0x8(%rsi), %rdx
xorl %edi, %edi
movaps 0x3eaf(%rip), %xmm0     # 0x111c0
testl %ecx, %ecx
jle 0xd332
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 0xd31c
incq %rdi
cmpq %rax, %rdi
jne 0xd311
movq %rbx, %rdi
callq 0xa5a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd77a
movl %ecx, %r12d
testl %ecx, %ecx
jg 0xd77a
movl %r9d, %r13d
movl %r8d, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x3bbd(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xd6b0
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl %r15d, %esi
movl %r13d, %edx
xorl %ecx, %ecx
callq 0xa262
movslq (%rbx), %rax
testq %rax, %rax
jle 0xd768
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 0xd6a3
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 0xd68f
incq %r8
cmpq %rax, %r8
jne 0xd67d
jmp 0xd768
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3b36(%rip), %rsi      # 0x111f5
leaq 0x3b36(%rip), %rdx      # 0x111fc
leaq -0x50(%rbp), %rdi
callq 0x93ea
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
movl %r15d, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x106da
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xd703
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movl (%rbx), %edi
testl %edi, %edi
jle 0xd768
movslq %r12d, %rax
movslq -0x2c(%rbp), %rcx
movl 0x4(%rbx), %esi
shlq $0x4, %rax
xorl %edx, %edx
testl %esi, %esi
jle 0xd75d
leaq (,%rdx,8), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq (%rsi,%rcx,8), %rsi
addq %rax, %rsi
movq 0x10(%rbx), %r10
movq (%r10,%rdx,8), %r10
movups (%r8,%rsi), %xmm0
movups %xmm0, (%r10,%r8)
incq %r9
movslq 0x4(%rbx), %rsi
addq $0x10, %r8
cmpq %rsi, %r9
jl 0xd72b
movl (%rbx), %edi
incq %rdx
movslq %edi, %r8
cmpq %r8, %rdx
jl 0xd719
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 0x3aba(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x882b(%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 0xd7bb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa5a6
movq 0x8(%r15), %rdi
movl (%r14), %esi
movsd 0x3762(%rip), %xmm0     # 0x11170
movq %rbx, %rdx
callq 0xda95
movq 0x8(%r15), %rcx
movslq (%r14), %rax
movq (%rcx), %rdx
movsd (%rdx), %xmm0
cmpq $0x2, %rax
jl 0xda40
movl $0x1, %edx
movq (%rcx,%rdx,8), %rsi
mulsd (%rsi,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xda2f
movl (%rbx,%rax,4), %ecx
subl %eax, %ecx
testb $0x1, %cl
je 0xda52
xorpd 0x376e(%rip), %xmm0     # 0x111c0
xorpd %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0x3710(%rip), %xmm2     # 0x11178
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
movapd %xmm2, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa186
movaps -0x30(%rbp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x1, %eax
testl %esi, %esi
js 0xdba6
leal 0x1(%rsi), %ecx
xorl %r8d, %r8d
movl %r8d, (%rdx,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0xdaa8
testl %esi, %esi
je 0xdba6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ecx
movl $0x1, %esi
xorl %r9d, %r9d
movapd 0x370b(%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 0xdadf
ucomisd %xmm2, %xmm0
ja 0xdba0
movl %r9d, %r10d
cmpq %r10, %r8
je 0xdb3d
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 0xdb92
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 0xdb66
incq %r11
cmpq %rcx, %r11
jne 0xdb4d
incq %rsi
cmpq %rcx, %r9
jne 0xdad5
jmp 0xdba2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdbd0
movl %edx, %eax
movl $0x1, %ecx
movq (%rdi,%rcx,8), %r8
mulsd (%r8,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xdbbe
movslq %edx, %rax
movl (%rsi,%rax,4), %eax
subl %edx, %eax
testb $0x1, %al
je 0xdbe4
xorpd 0x35dc(%rip), %xmm0     # 0x111c0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl 0x4(%rdi), %eax
jne 0xdd3a
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0xdc27
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%rax), %xmm0
jmp 0xdd19
jl 0xdd11
movsd 0x3523(%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 0xd7c4
movq %r15, %rdi
callq 0xdbe6
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 0x10952
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 0xa186
movaps -0x60(%rbp), %xmm0
xorps 0x34c8(%rip), %xmm0     # 0x111c0
movaps %xmm0, -0x60(%rbp)
incq %r14
movslq (%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r14
jl 0xdc5a
jmp 0xdd1e
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 0x34fa(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x826b(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl 0x4(%rdi), %eax
jne 0xde49
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0xdda6
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
jmp 0xde34
jl 0xde31
movsd 0x33a4(%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 0xd7c4
movq %r15, %rdi
callq 0xdd76
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 0xa186
movaps -0x30(%rbp), %xmm0
xorps 0x33a0(%rip), %xmm0     # 0x111c0
movaps %xmm0, -0x30(%rbp)
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xddc7
jmp 0xde39
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 0x33eb(%rip), %rcx      # 0x11245
movq %rcx, (%rax)
movq 0x815c(%rip), %rsi      # 0x15fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x34d0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa186
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe0ba
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 0x10952
addq $0x10, %r14
addq $0x8, %r15
cmpq %r14, %r13
jne 0xe09f
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 0xe0e1
movaps 0x30e5(%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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30de(%rip), %rsi      # 0x111f5
movq %r15, %rdi
callq 0x30e0
testl %eax, %eax
je 0xe19a
leaq 0x30cb(%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 0xa262
movslq (%r14), %rax
testq %rax, %rax
movsd -0x30(%rbp), %xmm1
jle 0xe269
movl 0x4(%r14), %ecx
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0xe18d
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 0xe175
incq %rdi
cmpq %rax, %rdi
jne 0xe166
jmp 0xe269
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x304b(%rip), %rsi      # 0x111f5
leaq 0x304b(%rip), %rdx      # 0x111fc
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x93ea
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x106da
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xe1ef
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movl (%r14), %ecx
testl %ecx, %ecx
movsd -0x30(%rbp), %xmm4
jle 0xe269
movl 0x4(%r14), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0xe25e
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 0xe20f
movl (%r14), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xe202
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 0xe293
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2af2(%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 0x934c
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa83c
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0xa5fe
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
callq 0xa5a6
leaq -0xd0(%rbp), %rdi
callq 0xa186
leaq -0x98(%rbp), %rdi
callq 0xa186
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe792
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3300
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe7a7
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 0xe7d0
jmp 0xe7e7
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xa186
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe7ea
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3300
jmp 0xe7ea
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe7ff
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O3/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 0x295b(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xe900
movl (%r14), %edx
movl 0x4(%r14), %esi
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa262
movslq (%rbx), %rax
testq %rax, %rax
jle 0xe9a3
movl 0x4(%rbx), %ecx
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0xe8f3
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 0xe8db
incq %rdi
cmpq %rax, %rdi
jne 0xe8d0
jmp 0xe9a3
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x28e5(%rip), %rsi      # 0x111f5
leaq 0x28e5(%rip), %rdx      # 0x111fc
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x93ea
movl (%r14), %ecx
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x106da
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe953
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movl (%rbx), %edx
testl %edx, %edx
jle 0xe9a3
movl 0x4(%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
jle 0xe998
movq %rax, %rdx
shlq $0x4, %rdx
xorl %esi, %esi
xorl %edi, %edi
movq 0x10(%r14), %rcx
movq (%rcx,%rdi,8), %rcx
movq 0x10(%rbx), %r8
movq (%r8,%rax,8), %r8
movups (%rcx,%rdx), %xmm0
movups %xmm0, (%r8,%rsi)
incq %rdi
movslq 0x4(%rbx), %rcx
addq $0x10, %rsi
cmpq %rcx, %rdi
jl 0xe96d
movl (%rbx), %edx
incq %rax
movslq %edx, %rsi
cmpq %rsi, %rax
jl 0xe95e
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 0xe9cb
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27ff(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xea69
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa262
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xeb21
movl 0x4(%rbx), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0xea59
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 0xea2a
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xea23
jmp 0xeb21
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x277c(%rip), %rsi      # 0x111f5
leaq 0x277c(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x93ea
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x106da
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xeabc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xeb21
movl 0x4(%rbx), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0xeb16
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 0xead5
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xeac8
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 0xeb4b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x267f(%rip), %rsi      # 0x111f5
callq 0x30e0
testl %eax, %eax
je 0xebe9
movl (%r14), %esi
movl 0x4(%r14), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa262
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xeca1
movl 0x4(%rbx), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0xebd9
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 0xebaa
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xeba3
jmp 0xeca1
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x25fc(%rip), %rsi      # 0x111f5
leaq 0x25fc(%rip), %rdx      # 0x111fc
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x93ea
movl (%r14), %edx
movl 0x4(%r14), %ecx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x106da
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xec3c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xeca1
movl 0x4(%rbx), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0xec96
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 0xec55
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xec48
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 0xeccb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3520
nop