LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::T() const
Matrix Matrix::T() const
{
	Matrix C(mShape[1],mShape[0]);
	for (int i=0; i<mShape[1];  i++){
		for (int j=0; j<mShape[0]; j++){
			C.mData[i][j] = mData[j][i];
		}
	}
	return C;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %esi
callq 0x2d58
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movq (%rbx), %rsi
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2fe0
movq (%r14), %rdi
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x2fdb
movq (%rdi,%r8,8), %r9
movsd (%r9,%rdx,8), %xmm0
movq (%rsi,%rdx,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x2fbd
incq %rdx
jmp 0x2fb2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::get_col(int)
Vector Matrix::get_col(int k)
{
	//std::cout<<"before all"<<std::endl<< std::flush;
	Vector v(mShape[0]);
  //	std::cout<<"after vec"<<std::endl<< std::flush;
	for (int i =1 ; i<=mShape[0]; i++){
		//std::cout<<"pre-definition"<<std::endl<< std::flush;
		//std::cout<< "this is the val  "<< mData[i][k]<< "this is the size  "<<mShape[0] << std::endl<< std::flush;
		v.set_val(i, mData[i-1][k-1]);
		//std::cout<<"in for loop"<<std::endl<< std::flush;
	}
	//std::cout<<"before return"<<std::endl<< std::flush;
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8068
movslq %ebp, %r12
pushq $0x1
popq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jg 0x303b
movq (%r14), %rax
movq -0x8(%rax,%r15,8), %rax
movsd -0x8(%rax,%r12,8), %xmm0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x89d4
incq %r15
jmp 0x3013
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::get_row(int)
Vector Matrix::get_row(int k)
{
	Vector v(mShape[0]);
	for (int i =1 ; i<=mShape[1]; i++){
		v.set_val(i, mData[k-1][i-1]);
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8068
movslq %ebp, %r12
pushq $0x1
popq %r15
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jg 0x30a1
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rax
movsd -0x8(%rax,%r15,8), %xmm0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x89d4
incq %r15
jmp 0x3079
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator+(Matrix const&, Matrix const&)
Matrix operator+(const Matrix& A, const Matrix& B)
{
	assert(A.mShape[1] == B.mShape[1] && A.mShape[0] == B.mShape[0]);
	Matrix W(A.mShape[0], A.mShape[1]);
  	W.mData=new double* [W.mShape[0]];
  	for (int i=0; i<W.mShape[0];  i++){
  		W.mData[i] = new double[W.mShape[1]];
  		for (int j=0; j<W.mShape[1]; j++){
  			W.mData[i][j] = A.mData[i][j]+ B.mData[i][j];
  		}
  	}
  return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rax
movq %rdi, (%rsp)
movl 0xc(%rsi), %edx
cmpl 0xc(%rax), %edx
jne 0x31a8
movq %rsi, %r13
movl 0x8(%rsi), %esi
cmpl 0x8(%rax), %esi
jne 0x31a8
movq %rax, 0x8(%rsp)
movq (%rsp), %r14
movq %r14, %rdi
callq 0x2d58
movslq 0x8(%r14), %rbp
leaq (,%rbp,8), %rdi
testq %rbp, %rbp
pushq $-0x1
popq %rbx
cmovsq %rbx, %rdi
callq 0x2030
movq %rax, 0x10(%rsp)
movq %rax, (%r14)
movslq 0xc(%r14), %rax
leaq (,%rax,8), %r15
testq %rax, %rax
cmovsq %rbx, %r15
movq (%r13), %r13
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %r12d
cmovgl %eax, %r12d
movq 0x8(%rsp), %rax
movq (%rax), %r14
testl %ebp, %ebp
cmovlel %ebx, %ebp
cmpq %rbp, %rbx
je 0x3195
movq %r15, %rdi
callq 0x2030
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x3190
movq (%r13,%rbx,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq (%r14,%rbx,8), %rdx
addsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x316e
incq %rbx
jmp 0x3156
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f69(%rip), %rdi      # 0x9118
leaq 0x5f9b(%rip), %rsi      # 0x9151
leaq 0x5f9f(%rip), %rcx      # 0x915c
pushq $0x5f
popq %rdx
callq 0x20b0
jmp 0x31c7
movq %rax, %r14
movq (%rsp), %rdi
callq 0x2dea
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator+(Matrix const&, double)
Matrix operator+(const Matrix& A, const double k)
{
	Matrix W(A.mShape[0], A.mShape[1]);
  	W.mData=new double* [W.mShape[0]];
  	for (int i=0; i<W.mShape[0];  i++){
  		W.mData[i] = new double[W.mShape[1]];
  		for (int j=0; j<W.mShape[1]; j++){
  			W.mData[i][j] = A.mData[i][j]+ k;
  		}
  	}
  return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2d58
movslq 0x8(%r15), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
pushq $-0x1
popq %rbx
cmovsq %rbx, %rdi
movq %r15, 0x8(%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%r15)
movslq 0xc(%r15), %rax
leaq (,%rax,8), %r15
testq %rax, %rax
cmovsq %rbx, %r15
xorl %ebp, %ebp
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
movq (%r12), %r12
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %r13, %rbp
je 0x3288
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbp,8)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x3283
movq (%r12,%rbp,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x3265
incq %rbp
jmp 0x3252
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x329e
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2dea
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::operator=(Matrix const&)
Matrix& Matrix::operator=(const Matrix& A)
{
  if (A.mShape[0] != mShape[0] || A.mShape[1] != mShape[1])
    {
      throw Exception("size mismatch",
		  "matrix assignment operator - matrices have different lengths");
    }
  else
    {
	  for (int i=0; i<mShape[0];  i++){
	  		mData[i] = new double[mShape[1]];
	  		for (int j=0; j<mShape[1]; j++){
	  			mData[i][j] = A.mData[i][j];
	  		}
	  }
  }
  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rsi), %r12d
cmpl 0x8(%rdi), %r12d
jne 0x346b
movq %rsi, %r14
movq %rdi, %rbx
movslq 0xc(%rsi), %rax
cmpl 0xc(%rdi), %eax
jne 0x346b
movq %rax, %rcx
shlq $0x3, %rcx
xorl %r13d, %r13d
testl %eax, %eax
pushq $-0x1
popq %r15
cmovnsq %rcx, %r15
movl $0x0, %ebp
cmovgl %eax, %ebp
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r12, %r13
je 0x3459
movq %r15, %rdi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq (%r14), %rax
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %rbp
je 0x3454
movq (%rax,%r13,8), %rsi
movsd (%rsi,%rdx,8), %xmm0
movq (%rcx,%r13,8), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x3438
incq %r13
jmp 0x341c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x5d41(%rip), %rsi      # 0x91be
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2060
leaq 0x5d39(%rip), %rsi      # 0x91cc
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x98e0(%rip), %rsi      # 0xcda0
leaq 0x4b8b(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2070
jmp 0x34e4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x2070
testb %bpl, %bpl
jne 0x34f8
jmp 0x3500
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator-(Matrix const&)
Matrix operator-(const Matrix& C)
{
	Matrix W(C.mShape[0],C.mShape[1]);
	W.mData=new double* [W.mShape[0]];
	for (int i=0; i<W.mShape[0];  i++){
		W.mData[i] = new double[W.mShape[1]];
		for (int j=0; j<W.mShape[1]; j++){
			W.mData[i][j] = -C.mData[i][j];
		}
	}
	return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2d58
movslq 0x8(%r15), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
pushq $-0x1
popq %rbx
cmovsq %rbx, %rdi
movq %r15, (%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%r15)
movslq 0xc(%r15), %rax
leaq (,%rax,8), %r15
testq %rax, %rax
cmovsq %rbx, %r15
movq (%r12), %r12
xorl %ebp, %ebp
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %r13, %rbp
je 0x35ab
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbp,8)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x35a6
movq (%r12,%rbp,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
xorps 0x5ac3(%rip), %xmm0     # 0x9060
movlps %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x3588
incq %rbp
jmp 0x3575
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35c0
movq %rax, %r14
movq (%rsp), %rdi
callq 0x2dea
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix&, Matrix&)
Matrix operator*(Matrix& A, Matrix& B){
	assert(A.mShape[1] == B.mShape[0]);
	Matrix C(A.mShape[0],B.mShape[1]);
	//std::cout<<C<<std::endl;
  Matrix AT = A.T();
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<B.mShape[1]; j++){
		//	C.mData[i][j] = s_prod(A.get_col(i+1), B.T().get_col(j+1), A.mShape[0]);
			C.set_val(i+1,j+1 , (AT.get_col(i+1) * B.get_col(j+1)));
		}
	}
	return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0xc(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x36ba
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%rdx), %edx
callq 0x2d58
leaq 0x18(%rsp), %rdi
movq %r15, 0x8(%rsp)
movq %r15, %rsi
movq %rbx, (%rsp)
callq 0x2f86
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x38(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
cmpq %rax, %r13
jge 0x369d
leaq 0x1(%r13), %rbx
xorl %r15d, %r15d
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jge 0x3698
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
movl %ebx, %edx
callq 0x2ff4
leal 0x1(%r15), %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2ff4
movq %r12, %rdi
movq %rbp, %rsi
callq 0x835f
movq 0x10(%rsp), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%r15,8)
movq %rbp, %rdi
callq 0x8104
movq %r12, %rdi
callq 0x8104
incq %r15
jmp 0x3642
movq %rbx, %r13
jmp 0x362d
leaq 0x18(%rsp), %rdi
callq 0x2dea
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b48(%rip), %rdi      # 0x9209
leaq 0x5a89(%rip), %rsi      # 0x9151
leaq 0x5b55(%rip), %rcx      # 0x9224
movl $0xaa, %edx
callq 0x20b0
movq %rax, %rbx
jmp 0x3709
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8104
jmp 0x36f0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8104
jmp 0x36ff
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2dea
movq (%rsp), %rdi
callq 0x2dea
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix&, Vector&)
Vector operator*(Matrix& A, Vector& b){
	assert(nrows(A) == length(b));
	int k = length(b);
	Vector v(k);
	for (int i=1; i<=k;  i++){
		v.set_val(i, A.get_row(i)*b);
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
movq %rdx, %rdi
callq 0x8915
cmpl %eax, %ebp
jne 0x37ca
movq %r14, %rdi
callq 0x8915
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x8068
xorl %ebp, %ebp
testl %r12d, %r12d
cmovgl %r12d, %ebp
negl %ebp
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r13
leal (%r12,%rbp), %eax
cmpl $0x1, %eax
je 0x37b8
movq %r13, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x305a
movq %r13, %rdi
movq %r14, %rsi
callq 0x835f
movq %rbx, %rdi
movl %r12d, %esi
callq 0x89d4
movq %r13, %rdi
callq 0x8104
incl %r12d
jmp 0x377e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a78(%rip), %rdi      # 0x9249
leaq 0x5979(%rip), %rsi      # 0x9151
leaq 0x5a80(%rip), %rcx      # 0x925f
movl $0xb8, %edx
callq 0x20b0
movq %rax, %r14
jmp 0x37fb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8104
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix const&, double const&)
Matrix operator*(const Matrix& A, const double& a)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
			C.mData[i][j] = a*A.mData[i][j];
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl 0xc(%r15), %edx
callq 0x2d58
movl 0x8(%r15), %eax
movl 0xc(%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movq (%r14), %rsi
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rax, %rdx
je 0x386e
movq (%r15), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x3869
movsd (%rbx), %xmm0
movq (%rdi,%rdx,8), %r9
mulsd (%r9,%r8,8), %xmm0
movq (%rsi,%rdx,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x3847
incq %rdx
jmp 0x383c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator/(double const&, Matrix const&)
Matrix operator/(const double& a,const Matrix& A)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
      if (A.mData[i][j]!=0){
			     C.mData[i][j] = a/A.mData[i][j];
      }
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2d58
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
movq (%r14), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
cmpq %rax, %rsi
je 0x38e8
movq (%rbx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x38e3
movq (%rdi,%rsi,8), %r9
movsd (%r9,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x38cb
jnp 0x38de
movsd (%r15), %xmm2
divsd %xmm1, %xmm2
movq (%rdx,%rsi,8), %r9
movsd %xmm2, (%r9,%r8,8)
incq %r8
jmp 0x38b4
incq %rsi
jmp 0x38a9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(double const&, Matrix const&)
Matrix operator*(const double& a, const Matrix& A)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
			C.mData[i][j] = a*A.mData[i][j];
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2d58
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movq (%r14), %rsi
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rax, %rdx
je 0x3952
movq (%rbx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x394d
movsd (%r15), %xmm0
movq (%rdi,%rdx,8), %r9
mulsd (%r9,%r8,8), %xmm0
movq (%rsi,%rdx,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x392a
incq %rdx
jmp 0x391f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& output, const Matrix& C) {
  for (int i=0; i<C.mShape[0]; i++)
    {
	  output << "(";
	  for (int j=0; j<C.mShape[1]; j++)
	      {
		  output <<  C.mData[i][j];
		  if (j<C.mShape[1]-1)
			  output  << ",\t";
		  else
			  output  << "";
	      }
	  output <<")\n";
    }
  return output;  // for multiple << operators.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x590e(%rip), %rbp      # 0x9284
leaq 0x5909(%rip), %r15      # 0x9286
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x39e8
movq %rbx, %rdi
leaq 0x5cde(%rip), %rsi      # 0x966e
callq 0x2130
xorl %r12d, %r12d
movslq 0xc(%r14), %rax
cmpq %rax, %r12
jge 0x39d4
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x2180
movslq 0xc(%r14), %rax
decq %rax
cmpq %rax, %r12
movq %r15, %rsi
cmovlq %rbp, %rsi
movq %rbx, %rdi
callq 0x2130
incq %r12
jmp 0x3998
movq %rbx, %rdi
leaq 0x58a9(%rip), %rsi      # 0x9287
callq 0x2130
incq %r13
jmp 0x397d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: diag(Matrix const&)
Matrix diag(const Matrix& A){
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		C.mData[i][i] = A.mData[i][i];
	}
	return C;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r14), %edx
callq 0x2d58
movslq 0x8(%r14), %rax
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x3a38
movq (%rcx,%rsi,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rsi,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x3a1c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::diag()
Vector Matrix::diag(){
  Vector v(mShape[0]);
	if (mShape[0] <= mShape[1]){
		for (int i=0; i<mShape[0];  i++){
			v.set_val( i+1 , mData[i][i]);
		}
	}
	else {
		Vector v(mShape[1]);
		for (int i=0; i<mShape[1];  i++){
				v.set_val(i+1, mData[i][i]);
			}
		}
	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8068
movl 0xc(%r14), %esi
cmpl %esi, 0x8(%r14)
jle 0x3aa1
leaq 0x8(%rsp), %rdi
callq 0x8068
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movslq 0xc(%r14), %rcx
cmpq %rcx, %rax
jge 0x3acc
leaq 0x1(%rax), %r12
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %r15, %rdi
movl %r12d, %esi
callq 0x89d4
movq %r12, %rax
jmp 0x3a78
xorl %eax, %eax
movslq 0x8(%r14), %rcx
cmpq %rcx, %rax
jge 0x3ad6
leaq 0x1(%rax), %r15
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x89d4
movq %r15, %rax
jmp 0x3aa3
leaq 0x8(%rsp), %rdi
callq 0x8104
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3af6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8104
jmp 0x3af9
movq %rax, %r14
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: diag(Vector&)
Matrix diag(Vector& v){
	int k =length(v);
	Matrix C(k,k);
	for (int i=1; i<=k; i++){
		C.set_val(i,i, v(i));
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8915
movl %eax, %r15d
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x2d58
movq (%rbx), %r12
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x3b60
leal 0x1(%r13), %esi
movq %r14, %rdi
callq 0x86de
movsd (%rax), %xmm0
movq (%r12,%r13,8), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x3b3c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2dea
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& C){
	mShape[0]=C.mShape[0];
	mData=new double* [C.mShape[0]];
	mShape[1]=C.mShape[1];
	for (int i=0; i<C.mShape[0];  i++){
		mData[i] = new double[C.mShape[1]];
			for (int j=0; j<C.mShape[1]; j++){
				mData[i][j] =  C.mData[i][j];
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
movslq 0x8(%rsi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movl %eax, 0x8(%r14)
pushq $-0x1
popq %rbx
cmovsq %rbx, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, (%r14)
movslq 0xc(%r13), %rax
leaq (,%rax,8), %r12
testq %rax, %rax
movq %r14, (%rsp)
movl %eax, 0xc(%r14)
movq %r13, %r14
movslq 0x8(%r13), %r13
cmovsq %rbx, %r12
xorl %ebp, %ebp
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
cmpq %r13, %rbp
jge 0x3c22
movq %r12, %rdi
callq 0x2030
movq %rax, (%r15,%rbp,8)
movq (%r14), %rax
movq (%rsp), %rcx
movq (%rcx), %r15
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x3c1d
movq (%rax,%rbp,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq (%r15,%rbp,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x3c01
incq %rbp
jmp 0x3be4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: randm(Matrix&)
Matrix randm(Matrix& A){
	int m = nrows(A);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=m ; i++){
		for (int j=1; j<=m ; j++){
			A.set_val(i,j, (float)rand()/RAND_MAX);
		}
	}
	return A;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
leal 0x1(%r15), %r12d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
incl %r15d
decq %r12
pushq $0x1
popq %r13
cmpq %r15, %r13
je 0x3c95
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x3c90
callq 0x2050
cvtsi2ss %eax, %xmm0
mulss 0x53f6(%rip), %xmm0     # 0x9070
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x3c64
incq %r13
jmp 0x3c5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b80
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: er_graph(Matrix&, float)
Matrix er_graph(Matrix& A,float p){
  assert(nrows(A)==ncols(A));
	int s = nrows(A);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=s ; i++){
		for (int j=1; j<=i ; j++){
			A.set_val(i,j, p>(float)rand()/RAND_MAX);
      A.set_val(j,i, p>(float)rand()/RAND_MAX);
		}
	}
	return A;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movl 0x8(%rsi), %r15d
cmpl 0xc(%rsi), %r15d
jne 0x42d7
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
incl %r15d
pushq $0x1
popq %r12
cmpq %r15, %r12
je 0x42bb
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x42b3
callq 0x2050
cvtsi2ss %eax, %xmm0
mulss 0x4e1b(%rip), %xmm0     # 0x9070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x4db2(%rip), %xmm0     # 0x9018
ja 0x426b
xorps %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
callq 0x2050
cvtsi2ss %eax, %xmm0
mulss 0x4de6(%rip), %xmm0     # 0x9070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x4d7d(%rip), %xmm0     # 0x9018
ja 0x42a0
xorps %xmm0, %xmm0
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, -0x8(%rax,%r12,8)
incq %r13
jmp 0x423f
incq %r12
jmp 0x4237
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b80
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4fac(%rip), %rdi      # 0x928a
leaq 0x4e6c(%rip), %rsi      # 0x9151
leaq 0x4ff2(%rip), %rcx      # 0x92de
movl $0x16e, %edx            # imm = 0x16E
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: evec_c(Matrix&)
Vector evec_c(Matrix& A){
	assert(nrows(A) == ncols(A));
	// INITIALISATION
	Vector x(nrows(A));
  Vector xold(nrows(A));
  xold  = randv(xold);
  x  = randv(x);
  float eps = 1.0;
  float lam;
  while (eps>1e-15){
    x = A*x;
    lam = (xold*x)/xold.norm();
    x = x/x.norm();
    eps=(x-xold).norm();
    xold=x;
  }
  signed int s = (lam>0) - (lam<0);
  x= x*s;
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movl 0x8(%rsi), %esi
cmpl 0xc(%r14), %esi
jne 0x46e6
movq %rdi, %rbx
callq 0x8068
movl 0x8(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x8068
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x89e1
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x859c
movq %rsp, %rdi
callq 0x8104
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x89e1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x859c
movq %rsp, %r15
movq %r15, %rdi
callq 0x8104
movss 0x4ad8(%rip), %xmm1     # 0x9074
leaq 0x28(%rsp), %r12
pushq $0x2
popq %rbp
leaq 0x20(%rsp), %r13
cvtss2sd %xmm1, %xmm0
ucomisd 0x4ad3(%rip), %xmm0     # 0x9088
jbe 0x4684
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x372f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x859c
movq %r15, %rdi
callq 0x8104
movq %r12, %rdi
movq %rbx, %rsi
callq 0x835f
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x891a
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x891a
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x845c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x859c
movq %r15, %rdi
callq 0x8104
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8238
movq %r15, %rdi
movl %ebp, %esi
callq 0x891a
movsd 0x18(%rsp), %xmm1
divsd 0x10(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0x10(%rsp)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x8104
movq %r12, %rdi
movq %rbx, %rsi
callq 0x859c
movss 0x18(%rsp), %xmm1
jmp 0x45a9
xorps %xmm0, %xmm0
xorl %eax, %eax
movss 0x10(%rsp), %xmm1
ucomiss %xmm0, %xmm1
seta %al
xorl %ecx, %ecx
ucomiss %xmm1, %xmm0
seta %cl
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x83d5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x859c
movq %rsp, %rdi
callq 0x8104
leaq 0x28(%rsp), %rdi
callq 0x8104
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c2d(%rip), %rdi      # 0x931a
leaq 0x4a5d(%rip), %rsi      # 0x9151
leaq 0x4c34(%rip), %rcx      # 0x932f
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x20b0
jmp 0x471a
jmp 0x472d
jmp 0x471a
jmp 0x472d
jmp 0x471a
jmp 0x472d
movq %rax, %r14
jmp 0x473a
jmp 0x471a
jmp 0x471a
movq %rax, %r14
movq %rsp, %rdi
callq 0x8104
jmp 0x4730
jmp 0x472d
jmp 0x472d
jmp 0x472d
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8104
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::Vector(int)
Vector::Vector(int sizeVal)
{
  mData=new double[sizeVal];
  mSize = sizeVal;
  for (int i=0; i<mSize; i++)
  {
     mData[i] = 0.0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shlq $0x3, %rax
xorl %r15d, %r15d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movl $0x0, %r12d
cmovgl %esi, %r12d
callq 0x2030
movq %rax, (%r14)
movl %ebx, 0x8(%r14)
cmpq %r15, %r12
je 0x80ac
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x809d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::Vector(Vector const&)
Vector::Vector(const Vector& v1)
{
  mSize = v1.mSize;
  mData=new double[mSize];
  for (int i=0; i<v1.mSize; i++)
  {
    mData[i] = v1.mData[i];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x8(%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%r14)
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %r15, %rdx
jge 0x80fe
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x80ea
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator+(Vector const&, Vector const&)
Vector operator+(const Vector& v1, 
                        const Vector& v2)
{
  int n;

  //  set n to be the length of the longest vector and create a vector
  //  of that length to be returned
  if (v1.mSize > v2.mSize)
    {
      n = v1.mSize;
    }
  else
    {
      n = v2.mSize;
    }
  Vector w(n);


  //  add the vectors
  //  if one vector is shorter than the other assume missing entries are 0
  if (v1.mSize == v2.mSize)
  {
      for (int i=0; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] + v2.mData[i];
	}
  }
  else if (v1.mSize > v2.mSize)
  {
      for (int i=0; i<v2.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] + v2.mData[i];
	}
      for (int i=v2.mSize; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i];
	}
      std::cerr<<"vector add - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
  }

  else
  {
      for (int i=0; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] + v2.mData[i];
	}
      for (int i=v1.mSize; i<v2.mSize; i++)
	{
	  w.mData[i] = v2.mData[i];
	}
      std::cerr<<"vector add - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
  }
  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0x8(%rdx), %esi
cmpl %esi, %eax
cmovgl %eax, %esi
callq 0x8068
movslq 0x8(%r15), %rax
movslq 0x8(%r14), %rcx
cmpl %ecx, %eax
jne 0x8168
movq (%r15), %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
cmpq %rdi, %rax
je 0x821c
movsd (%rcx,%rdi,8), %xmm0
addsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0x814b
movq (%r15), %rsi
movq (%r14), %rdi
movq (%rbx), %rdx
xorl %r8d, %r8d
cmpl %ecx, %eax
jle 0x81a0
testl %ecx, %ecx
movl $0x0, %r9d
cmovgl %ecx, %r9d
cmpq %r8, %r9
je 0x81c8
movsd (%rsi,%r8,8), %xmm0
addsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
jmp 0x8184
testl %eax, %eax
movl $0x0, %r9d
cmovgl %eax, %r9d
cmpq %r8, %r9
je 0x81df
movsd (%rsi,%r8,8), %xmm0
addsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
jmp 0x81ac
movq (%r15), %rsi
cmpq %rax, %rcx
jge 0x81f6
movsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x81cb
movq (%r14), %rsi
cmpq %rax, %rcx
je 0x81f6
movsd (%rsi,%rax,8), %xmm0
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x81e2
movq 0x4df3(%rip), %rdi      # 0xcff0
leaq 0x12ec(%rip), %rsi      # 0x94f0
callq 0x2130
movq 0x4de0(%rip), %rdi      # 0xcff0
leaq 0x1301(%rip), %rsi      # 0x9518
callq 0x2130
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator-(Vector const&, Vector const&)
Vector operator-(const Vector& v1, 
                        const Vector& v2)
{
  int n;

//  set n to be the length of the longest vector and create a vector
//  of that length to be returned
  if (v1.mSize > v2.mSize)
    {
      n = v1.mSize;
    }
  else
    {
      n = v2.mSize;
    }
  Vector w(n);


//  subtract the vectors
//  if one vector is shorter than the other assume missing entries are 0
  if (v1.mSize == v2.mSize)
    {
      for (int i=0; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] - v2.mData[i];
	}
    }

  else if (v1.mSize > v2.mSize)
    {
      for (int i=0; i<v2.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] - v2.mData[i];
	}
      for (int i=v2.mSize; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i];
	}
      std::cerr<<"vector subtract - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }

  else
    {
      for (int i=0; i<v1.mSize; i++)
	{
	  w.mData[i] = v1.mData[i] - v2.mData[i];
	}
      for (int i=v1.mSize; i<v2.mSize; i++)
	{
	  w.mData[i] = v2.mData[i];
	}
      std::cerr<<"vector subtract - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }
  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0x8(%rdx), %esi
cmpl %esi, %eax
cmovgl %eax, %esi
callq 0x8068
movslq 0x8(%r15), %rax
movslq 0x8(%r14), %rcx
cmpl %ecx, %eax
jne 0x828f
movq (%r15), %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
cmpq %rdi, %rax
je 0x8343
movsd (%rcx,%rdi,8), %xmm0
subsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0x8272
movq (%r15), %rsi
movq (%r14), %rdi
movq (%rbx), %rdx
xorl %r8d, %r8d
cmpl %ecx, %eax
jle 0x82c7
testl %ecx, %ecx
movl $0x0, %r9d
cmovgl %ecx, %r9d
cmpq %r8, %r9
je 0x82ef
movsd (%rsi,%r8,8), %xmm0
subsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
jmp 0x82ab
testl %eax, %eax
movl $0x0, %r9d
cmovgl %eax, %r9d
cmpq %r8, %r9
je 0x8306
movsd (%rsi,%r8,8), %xmm0
subsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
jmp 0x82d3
movq (%r15), %rsi
cmpq %rax, %rcx
jge 0x831d
movsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x82f2
movq (%r14), %rsi
cmpq %rax, %rcx
je 0x831d
movsd (%rsi,%rax,8), %xmm0
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x8309
movq 0x4ccc(%rip), %rdi      # 0xcff0
leaq 0x1220(%rip), %rsi      # 0x954b
callq 0x2130
movq 0x4cb9(%rip), %rdi      # 0xcff0
leaq 0x11da(%rip), %rsi      # 0x9518
callq 0x2130
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8104
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(Vector const&, Vector const&)
double operator*(const Vector& v1, const Vector& v2)
{
  int n;
  double dp;


//  check vectors are of the same length
//  if not assume missing entries are 0 
  if (v1.mSize > v2.mSize)
    {
      n = v2.mSize;
      std::cerr<<"scalar product - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }
  else if (v1.mSize < v2.mSize)
    {
      n = v1.mSize;
      std::cerr<<"scalar product - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }
  else
    {
      n = v1.mSize;
    }



//  compute scalar product

  dp = 0.0;

  for (int i=0; i<n; i++)
    {
      dp += v1.mData[i] * v2.mData[i];
    }

  return dp;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl 0x8(%rsi), %ebp
cmpl %ebp, %eax
jg 0x837a
movl %eax, %ebp
jge 0x83a1
movq 0x4c6f(%rip), %r15      # 0xcff0
leaq 0x11f0(%rip), %rsi      # 0x9578
movq %r15, %rdi
callq 0x2130
leaq 0x1181(%rip), %rsi      # 0x9518
movq %r15, %rdi
callq 0x2130
movl %ebp, %eax
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
cmpq %rsi, %rax
je 0x83ca
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x83b2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(Vector const&, double const&)
Vector operator*(const Vector& v, const double& a)
{

//  create a vector of the same length as v with entries equal to a*v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = a * v.mData[i];
    }

  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
callq 0x8068
movslq 0x8(%r15), %rax
movq (%r15), %rcx
movq (%r14), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x840f
movsd (%rbx), %xmm0
mulsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x83f7
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(double const&, Vector const&)
Vector operator*(const double& a, const Vector& v)
{

//  create a vector of the same length as v with entries equal to a*v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = a * v.mData[i];
    }

  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %esi
callq 0x8068
movslq 0x8(%r15), %rax
movq (%r15), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x8453
movsd (%r14), %xmm0
mulsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x843a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator/(Vector const&, double const&)
Vector operator/(const Vector& v, const double& a)
{
  if (a == 0.0)
  {
     throw Exception("div 0", "Attempt to divide by zero");
  }
//  create a vector of the same length as v with entries equal to v/a

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = v.mData[i] / a;
    }

  return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd (%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8476
jnp 0x84b9
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
callq 0x8068
movslq 0x8(%r15), %rax
movq (%r15), %rcx
movq (%r14), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x84ab
movsd (%rcx,%rsi,8), %xmm0
divsd (%rbx), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x8493
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x10d9(%rip), %rsi      # 0x95a4
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2060
leaq 0x10c9(%rip), %rsi      # 0x95aa
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x4892(%rip), %rsi      # 0xcda0
leaq -0x4c3(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2070
jmp 0x8532
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x2070
testb %bpl, %bpl
jne 0x8546
jmp 0x854e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator-(Vector const&)
Vector operator-(const Vector& v)
{

//  create a vector w with entries equal to -v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = -v.mData[i];
    }

  return w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8068
movslq 0x8(%r14), %rax
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movaps 0xae5(%rip), %xmm0      # 0x9060
cmpq %rax, %rsi
jge 0x8591
movsd (%rcx,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdx,%rsi,8)
incq %rsi
jmp 0x857b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::operator=(Vector const&)
Vector& Vector::operator=(const Vector& v)
{

//  check both vectors have same length
//  if rhs vector is too short, assume missing entries are 0
//  if rhs vector is too long then throw

  if (v.mSize > mSize)
    {
      throw Exception("length mismatch",
		  "vector assignment operator - vectors have different lengths");
    }
  else if (v.mSize < mSize)
    {
      for (int i=0; i<v.mSize; i++)
	{
	  mData[i] = v.mData[i];
	}
      for (int i=v.mSize; i<mSize; i++)
	{
	  mData[i] = 0.0;
	}
      std::cerr << "vector assignment operator - copied vector was too short";
      std::cerr << " and has been extended with zeroes\n";
    }
  else
    {
      for (int i=0; i<mSize; i++)
	{
	  mData[i] = v.mData[i];
	}
    }

  return *this;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movslq 0x8(%rsi), %rcx
movslq 0x8(%rdi), %rax
cmpl %eax, %ecx
jg 0x8641
movq %rdi, %rbx
movq (%rsi), %rdx
movq (%rdi), %rsi
cmpl %eax, %ecx
jge 0x85e3
xorl %edi, %edi
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %ecx, %r8d
cmpq %rdi, %r8
je 0x85fe
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0x85cf
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x8635
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
jmp 0x85ea
movq (%rbx), %rdx
cmpq %rcx, %rax
je 0x8610
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0x8601
movq 0x49d9(%rip), %r14      # 0xcff0
leaq 0xfe2(%rip), %rsi       # 0x9600
movq %r14, %rdi
callq 0x2130
leaq 0x100c(%rip), %rsi      # 0x9639
movq %r14, %rdi
callq 0x2130
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0xa88(%rip), %rsi       # 0x90db
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2060
leaq 0xf5b(%rip), %rsi       # 0x95c4
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x470a(%rip), %rsi      # 0xcda0
leaq -0x64b(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2070
jmp 0x86ba
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x2070
testb %bpl, %bpl
jne 0x86ce
jmp 0x86d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::operator()(int)
double& Vector::operator()(int i)
{

  if (i < 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mSize)
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }


  return mData[i-1];

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testl %esi, %esi
jle 0x870b
cmpl %esi, 0x8(%rdi)
jl 0x8771
movq (%rdi), %rax
movl %esi, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x983(%rip), %rsi       # 0x90a0
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2060
leaq 0x97a(%rip), %rsi       # 0x90ad
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x4640(%rip), %rsi      # 0xcda0
leaq -0x715(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
jmp 0x87d5
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x958(%rip), %rsi       # 0x90db
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2060
leaq 0x952(%rip), %rsi       # 0x90eb
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x45da(%rip), %rsi      # 0xcda0
leaq -0x77b(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2070
jmp 0x87ea
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
jmp 0x880b
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x2070
jmp 0x8806
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x2070
testb %bpl, %bpl
jne 0x881c
jmp 0x8824
jmp 0x8819
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator<<(std::ostream&, Vector const&)
std::ostream& operator<<(std::ostream& output, const Vector& v) {
  output << "(";
  for (int i=0; i<v.mSize; i++)
    { 
      output <<  v.mData[i];
      if (i != v.mSize-1)
	output  << ", ";
      else
	output  << ")";
    }
  return output;  // for multiple << operators.
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe2c(%rip), %rsi       # 0x966e
callq 0x2130
xorl %r15d, %r15d
leaq 0xa31(%rip), %r12       # 0x9282
leaq 0xe05(%rip), %r13       # 0x965d
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x888f
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x2180
movl 0x8(%r14), %eax
decl %eax
cmpq %rax, %r15
movq %r13, %rsi
cmoveq %r12, %rsi
movq %rbx, %rdi
callq 0x2130
incq %r15
jmp 0x8858
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: norm(Vector&, int)
double norm(Vector& v, int p)
{
  double temp, norm_val;

  norm_val = 0.0;
  for (int i=1; i<=length(v); i++)
    {
      temp = fabs(v(i));
      norm_val += pow(temp, p);
    }

  return pow(norm_val, 1.0/((double) (p)));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorpd %xmm0, %xmm0
cmpl 0x8(%rbx), %ebp
jg 0x88fc
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x86de
movsd (%rax), %xmm0
andpd 0xc09(%rip), %xmm0      # 0x94e0
movsd 0x10(%rsp), %xmm1
callq 0x21c0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incl %ebp
jmp 0x88b6
movsd 0x714(%rip), %xmm1      # 0x9018
divsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::norm(int) const
double Vector::norm(int p) const
{
  double temp, norm_val;

  norm_val = 0.0;
  for (int i=0; i<mSize; i++)
    {
      temp = fabs(mData[i]);
      norm_val += pow(temp, p);
    }

  return pow(norm_val, 1.0/((double) (p)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x897b
movq (%rbx), %rax
movsd %xmm0, 0x8(%rsp)
movsd (%rax,%r14,8), %xmm0
andpd 0xb8b(%rip), %xmm0      # 0x94e0
movsd 0x10(%rsp), %xmm1
callq 0x21c0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r14
jmp 0x8935
movsd 0x695(%rip), %xmm1      # 0x9018
divsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: ones(int)
Vector ones(const int a)
{
	Vector b(a);
	for (int i=1; i<=a; i++){
		b.set_val(i,1);
	}
  return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x8068
movq (%rbx), %rax
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
cmpq %rcx, %r14
je 0x89c8
movq %rdx, (%rax,%rcx,8)
incq %rcx
jmp 0x89ba
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Vector.cpp
// Function: randv(Vector&)
Vector randv(Vector& v){
	int m = length(v);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=m ; i++){
			v.set_val(i,(float)rand()/RAND_MAX);
	}
	return v;


}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x8a25
callq 0x2050
cvtsi2ss %eax, %xmm0
mulss 0x65d(%rip), %xmm0      # 0x9070
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x89fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop