LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x33(%rsp)
movl 0x8(%rax), %esi
callq 0xd040
movl $0x1, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jg 0x3b83
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %esi
movq (%rax), %rax
movl %esi, %ecx
decl %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0x34(%rsp), %ecx
decl %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0xe480
jmp 0x3b5b
jmp 0x3b5d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3b1d
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd170
jmp 0x3ba2
movb $0x1, 0x33(%rsp)
testb $0x1, 0x33(%rsp)
jne 0x3b98
movq (%rsp), %rdi
callq 0xd170
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x33(%rsp)
movl 0x8(%rax), %esi
callq 0xd040
movl $0x1, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jg 0x3c53
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %esi
movq (%rax), %rax
movl 0x34(%rsp), %ecx
decl %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %esi, %ecx
decl %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0xe480
jmp 0x3c2b
jmp 0x3c2d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3bed
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd170
jmp 0x3c72
movb $0x1, 0x33(%rsp)
testb $0x1, 0x33(%rsp)
jne 0x3c68
movq (%rsp), %rdi
callq 0xd170
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x40(%rsp), %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, 0x23(%rsp)
jne 0x3ccf
movq 0x48(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x3cd9
jmp 0x3cdb
jmp 0x3cfa
leaq 0xb42e(%rip), %rdi      # 0xf110
leaq 0xb460(%rip), %rsi      # 0xf149
movl $0x5f, %edx
leaq 0xb45f(%rip), %rcx      # 0xf154
callq 0x2090
movq 0x10(%rsp), %rdi
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x3560
movq 0x10(%rsp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
jmp 0x3d3f
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3e45
movq 0x10(%rsp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, (%rsp)
jmp 0x3d90
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3e33
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x24(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x24(%rsp), %rdx
addsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3dad
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x3660
jmp 0x3e65
jmp 0x3e35
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3d54
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x3e5b
movq 0x10(%rsp), %rdi
callq 0x3660
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21e0
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x3560
movq 0x10(%rsp), %rdi
movslq 0x8(%rdi), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, 0x18(%rsp)
jmp 0x3ed1
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3fc2
movq 0x10(%rsp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, (%rsp)
jmp 0x3f22
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3fb0
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x24(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
addsd 0x40(%rsp), %xmm0
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3f3f
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x3660
jmp 0x3fe2
jmp 0x3fb2
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3ee6
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x3fd8
movq 0x10(%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x88(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jne 0x422d
movq 0x18(%rsp), %rcx
movq 0x88(%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0xc(%rcx), %eax
je 0x4333
movb $0x1, 0x2e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x8(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21f0
movq 0x10(%rsp), %rdx
leaq 0xaf5a(%rip), %rsi      # 0xf1b6
leaq 0x68(%rsp), %rdi
callq 0x2150
jmp 0x4268
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21f0
movq (%rsp), %rdx
leaq 0xaf43(%rip), %rsi      # 0xf1c4
leaq 0x30(%rsp), %rdi
callq 0x2150
jmp 0x428d
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe550
jmp 0x42a3
movq 0x8(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0xdadc(%rip), %rsi      # 0x11d90
leaq 0x8d55(%rip), %rdx      # 0xd010
callq 0x21b0
jmp 0x4412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x42fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2080
leaq 0x2f(%rsp), %rdi
callq 0x2130
leaq 0x68(%rsp), %rdi
callq 0x2080
leaq 0x67(%rsp), %rdi
callq 0x2130
testb $0x1, 0x2e(%rsp)
jne 0x4324
jmp 0x432e
movq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x4408
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x43f9
movq 0x18(%rsp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x43e7
movq 0x18(%rsp), %rax
movq 0x88(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x24(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4393
jmp 0x43e9
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x433b
jmp 0x43fb
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x3560
movq 0x18(%rsp), %rdi
movslq 0x8(%rdi), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, 0x20(%rsp)
jmp 0x447b
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x457f
movq 0x18(%rsp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
jmp 0x44cd
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x456d
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x30(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x2c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x2c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x44eb
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x3660
jmp 0x459f
jmp 0x456f
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x4490
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x4595
movq 0x18(%rsp), %rdi
callq 0x3660
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x70(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x45ea
jmp 0x4609
leaq 0xac10(%rip), %rdi      # 0xf201
leaq 0xab51(%rip), %rsi      # 0xf149
movl $0xaa, %edx
leaq 0xac18(%rip), %rcx      # 0xf21c
callq 0x2090
movq 0x10(%rsp), %rdi
movb $0x0, 0x6f(%rsp)
movq 0x78(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x70(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x3560
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x39f0
jmp 0x4639
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x78(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4765
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x4753
movl 0x48(%rsp), %edx
incl %edx
movl %edx, 0x8(%rsp)
movl 0x44(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3ae0
jmp 0x4692
movq 0x70(%rsp), %rsi
movl 0x44(%rsp), %edx
incl %edx
leaq 0x20(%rsp), %rdi
callq 0x3ae0
jmp 0x46a9
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd740
movsd %xmm0, (%rsp)
jmp 0x46bf
movsd (%rsp), %xmm0
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x47c0
jmp 0x46d8
leaq 0x20(%rsp), %rdi
callq 0xd170
leaq 0x30(%rsp), %rdi
callq 0xd170
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x465b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x47a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x477d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4747
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd170
leaq 0x30(%rsp), %rdi
callq 0xd170
jmp 0x477d
jmp 0x4755
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x4641
movb $0x1, 0x6f(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3660
testb $0x1, 0x6f(%rsp)
jne 0x4793
jmp 0x4789
leaq 0x58(%rsp), %rdi
callq 0x3660
jmp 0x47a0
movq 0x10(%rsp), %rdi
callq 0x3660
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x3660
movq 0x50(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x3ac0
movl %eax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe310
movl %eax, %ecx
movl 0x20(%rsp), %eax
cmpl %ecx, %eax
jne 0x4844
jmp 0x4863
leaq 0xa9f6(%rip), %rdi      # 0xf241
leaq 0xa8f7(%rip), %rsi      # 0xf149
movl $0xb8, %edx
leaq 0xa9f9(%rip), %rcx      # 0xf257
callq 0x2090
movq 0x50(%rsp), %rdi
callq 0xe310
movq 0x10(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movb $0x0, 0x4b(%rsp)
movl 0x4c(%rsp), %esi
callq 0xd040
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jg 0x491f
movl 0x44(%rsp), %edx
movl %edx, 0xc(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3bb0
jmp 0x48b3
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xd740
movsd %xmm0, (%rsp)
jmp 0x48c9
movsd (%rsp), %xmm0
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0xe480
jmp 0x48de
leaq 0x30(%rsp), %rdi
callq 0xd170
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x488c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x493f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd170
jmp 0x493f
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x4935
movq 0x10(%rsp), %rdi
callq 0xd170
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xd170
movq 0x28(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x3560
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4a1f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x4a10
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x14(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x49b7
jmp 0x4a12
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x49a1
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x4a34
movq (%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x20(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x3560
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4b33
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x4b21
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4ad1
jp 0x4ad1
jmp 0x4b0f
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x14(%rsp), %rdx
divsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x4b11
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a9b
jmp 0x4b23
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4a81
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x4b48
movq (%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x20(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x3560
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4c1f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x4c10
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x14(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bb7
jmp 0x4c12
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4ba1
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x4c34
movq (%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4d15
movq 0x10(%rsp), %rdi
leaq 0xa9ea(%rip), %rsi      # 0xf65e
callq 0x2110
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x4cf4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2210
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4cd6
movq 0x10(%rsp), %rdi
leaq 0xa5ad(%rip), %rsi      # 0xf27c
callq 0x2110
jmp 0x4ce7
movq 0x10(%rsp), %rdi
leaq 0xa59c(%rip), %rsi      # 0xf27e
callq 0x2110
jmp 0x4ce9
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4c80
movq 0x10(%rsp), %rdi
leaq 0xa57f(%rip), %rsi      # 0xf27f
callq 0x2110
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4c56
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x18(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x3560
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4dac
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4d5c
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x4dc1
movq (%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x47(%rsp)
movl 0x8(%rax), %esi
callq 0xd040
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jg 0x4e70
movl $0x0, 0x40(%rsp)
movq 0x10(%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4e6b
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x40(%rsp), %rcx
movl %ecx, %esi
incl %esi
movq (%rax), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rcx,8), %xmm0
callq 0xe480
jmp 0x4e49
jmp 0x4e4b
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x4e16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x4f12
jmp 0x4ef3
movq 0x10(%rsp), %rax
movl 0xc(%rax), %esi
leaq 0x20(%rsp), %rdi
callq 0xd040
jmp 0x4e84
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x4ee9
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %ecx, %esi
incl %esi
movq (%rax), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rcx,8), %xmm0
leaq 0x20(%rsp), %rdi
callq 0xe480
jmp 0x4ec0
jmp 0x4ec2
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4e8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd170
jmp 0x4f12
leaq 0x20(%rsp), %rdi
callq 0xd170
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x4f08
movq (%rsp), %rdi
callq 0xd170
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq (%rsp), %rdi
callq 0xd170
movq 0x38(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xe310
movq 0x20(%rsp), %rdi
movl %eax, 0x44(%rsp)
movb $0x0, 0x43(%rsp)
movl 0x44(%rsp), %esi
movl 0x44(%rsp), %edx
callq 0x3560
movl $0x1, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jg 0x4fe3
movl 0x3c(%rsp), %esi
movl %esi, 0x8(%rsp)
movl %esi, %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rdi
callq 0xdee0
movq %rax, 0x10(%rsp)
jmp 0x4fa1
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
callq 0x47c0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4f78
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x3660
jmp 0x5003
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x4ff9
movq 0x20(%rsp), %rdi
callq 0x3660
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5136
movq 0x18(%rsp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x5124
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x50d3
jmp 0x5126
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x507b
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3ac0
movl %eax, 0x34(%rsp)
movl $0x1, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jg 0x51ee
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jg 0x51df
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x2060
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
cvtsi2ss %eax, %xmm0
movss 0x9e9f(%rip), %xmm1     # 0xf064
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x47c0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5183
jmp 0x51e1
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x5171
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x5010
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movss %xmm0, 0x74(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3ac0
movl %eax, 0x64(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3ad0
movl %eax, %ecx
movl 0x64(%rsp), %eax
cmpl %ecx, %eax
jne 0x5c0b
jmp 0x5c2a
leaq 0x9670(%rip), %rdi      # 0xf282
leaq 0x9530(%rip), %rsi      # 0xf149
movl $0x16e, %edx            # imm = 0x16E
leaq 0x96b1(%rip), %rcx      # 0xf2d6
callq 0x2090
movq 0x78(%rsp), %rdi
callq 0x3ac0
movl %eax, 0x70(%rsp)
movl $0x1, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x70(%rsp), %eax
jg 0x5d85
movl $0x1, 0x68(%rsp)
movl 0x68(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jg 0x5d73
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x2c(%rsp)
movss 0x74(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
callq 0x2060
movss 0x30(%rsp), %xmm0
cvtsi2ss %eax, %xmm1
movss 0x93c7(%rip), %xmm2     # 0xf068
movss %xmm2, 0x34(%rsp)
mulss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
movsd 0x937a(%rip), %xmm0     # 0xf030
movsd %xmm0, 0x38(%rsp)
xorps %xmm1, %xmm1
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x48(%rsp)
ja 0x5cd9
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %esi
movq 0x20(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
callq 0x47c0
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x10(%rsp)
movss 0x74(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
callq 0x2060
movss 0x34(%rsp), %xmm3
movss 0x14(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
cvtsi2ss %eax, %xmm2
mulss %xmm3, %xmm2
ucomiss %xmm2, %xmm1
movsd %xmm0, 0x18(%rsp)
ja 0x5d4c
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %esi
movq (%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x47c0
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x5c56
jmp 0x5d75
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x5c40
movq 0x50(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x5010
movq 0x58(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movslq 0xc(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0xd0c3
movq (%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xd095
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd16a
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd12b
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jle 0xd794
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x487d(%rip), %rdi      # 0x11ff0
leaq 0x1dee(%rip), %rsi      # 0xf568
callq 0x2110
movq 0x486a(%rip), %rdi      # 0x11ff0
leaq 0x1d7b(%rip), %rsi      # 0xf508
callq 0x2110
jmp 0xd7e8
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd7da
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x4837(%rip), %rdi      # 0x11ff0
leaq 0x1da8(%rip), %rsi      # 0xf568
callq 0x2110
movq 0x4824(%rip), %rdi      # 0x11ff0
leaq 0x1d35(%rip), %rsi      # 0xf508
callq 0x2110
jmp 0xd7e6
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0xd7e8
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xd848
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd7f9
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
callq 0xd040
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd8e2
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x18(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xd89a
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0xd8f8
movq 0x8(%rsp), %rdi
callq 0xd170
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
callq 0xd040
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd992
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x18(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xd94a
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0xd9a8
movq 0x8(%rsp), %rdi
callq 0xd170
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x90(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xdb13
jp 0xdb13
movb $0x1, 0x36(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x10(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21f0
movq 0x18(%rsp), %rdx
leaq 0x1b5a(%rip), %rsi      # 0xf594
leaq 0x70(%rsp), %rdi
callq 0x2150
jmp 0xda46
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21f0
movq 0x8(%rsp), %rdx
leaq 0x1b39(%rip), %rsi      # 0xf59a
leaq 0x38(%rsp), %rdi
callq 0x2150
jmp 0xda6d
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xe550
jmp 0xda83
movq 0x10(%rsp), %rdi
movb $0x0, 0x36(%rsp)
leaq 0x42fc(%rip), %rsi      # 0x11d90
leaq -0xa8b(%rip), %rdx      # 0xd010
callq 0x21b0
jmp 0xdbb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdaf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdadd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2080
leaq 0x37(%rsp), %rdi
callq 0x2130
leaq 0x70(%rsp), %rdi
callq 0x2080
leaq 0x6f(%rsp), %rdi
callq 0x2130
testb $0x1, 0x36(%rsp)
jne 0xdb04
jmp 0xdb0e
movq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0xdba9
movq 0x20(%rsp), %rdi
movb $0x0, 0x35(%rsp)
movq 0x98(%rsp), %rax
movl 0x8(%rax), %esi
callq 0xd040
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movq 0x98(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xdb86
movq 0x20(%rsp), %rax
movq 0x98(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x30(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x90(%rsp), %rcx
divsd (%rcx), %xmm0
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xdb35
movb $0x1, 0x35(%rsp)
testb $0x1, 0x35(%rsp)
jne 0xdb9c
movq 0x20(%rsp), %rdi
callq 0xd170
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
callq 0xd040
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xdc49
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xdbf4
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0xdc5e
movq (%rsp), %rdi
callq 0xd170
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x1, 0xec(%rsp)
jge 0xe052
movb $0x1, 0x8e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x20(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x21f0
movq 0x28(%rsp), %rdx
leaq 0x1152(%rip), %rsi      # 0xf098
leaq 0xc8(%rsp), %rdi
callq 0x2150
jmp 0xdf55
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21f0
movq 0x18(%rsp), %rdx
leaq 0x1132(%rip), %rsi      # 0xf0a5
leaq 0x90(%rsp), %rdi
callq 0x2150
jmp 0xdf82
movq 0x20(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0xe550
jmp 0xdf9e
movq 0x20(%rsp), %rdi
movb $0x0, 0x8e(%rsp)
leaq 0x3dde(%rip), %rsi      # 0x11d90
leaq -0xfa9(%rip), %rdx      # 0xd010
callq 0x21b0
jmp 0xe1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xe02a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xe010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2080
leaq 0x8f(%rsp), %rdi
callq 0x2130
leaq 0xc8(%rsp), %rdi
callq 0x2080
leaq 0xc7(%rsp), %rdi
callq 0x2130
testb $0x1, 0x8e(%rsp)
jne 0xe043
jmp 0xe04d
movq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0xe1a2
movq 0x30(%rsp), %rcx
movl 0xec(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0xe17c
movb $0x1, 0x3e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x8(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21f0
movq 0x10(%rsp), %rdx
leaq 0x103d(%rip), %rsi      # 0xf0d3
leaq 0x68(%rsp), %rdi
callq 0x2150
jmp 0xe0a2
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21f0
movq (%rsp), %rdx
leaq 0x1028(%rip), %rsi      # 0xf0e3
leaq 0x40(%rsp), %rdi
callq 0x2150
jmp 0xe0c7
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xe550
jmp 0xe0dd
movq 0x8(%rsp), %rdi
movb $0x0, 0x3e(%rsp)
leaq 0x3ca2(%rip), %rsi      # 0x11d90
leaq -0x10e5(%rip), %rdx     # 0xd010
callq 0x21b0
jmp 0xe1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xe15d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xe149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2080
leaq 0x3f(%rsp), %rdi
callq 0x2130
leaq 0x68(%rsp), %rdi
callq 0x2080
leaq 0x67(%rsp), %rdi
callq 0x2130
testb $0x1, 0x3e(%rsp)
jne 0xe170
jmp 0xe17a
movq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0xe1a2
jmp 0xe17e
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl 0xec(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0xf8, %rsp
retq
movq 0xb8(%rsp), %rdi
callq 0x21e0
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1494(%rip), %rsi      # 0xf65e
callq 0x2110
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xe247
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2210
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0xe227
movq 0x10(%rsp), %rdi
leaq 0x142d(%rip), %rsi      # 0xf64d
callq 0x2110
jmp 0xe238
movq 0x10(%rsp), %rdi
leaq 0x1047(%rip), %rsi      # 0xf27a
callq 0x2110
jmp 0xe23a
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe1d7
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xe310
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jg 0xe2e5
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xdee0
movsd (%rax), %xmm0
movaps 0x121f(%rip), %xmm1     # 0xf4d0
pand %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
callq 0x21d0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe27e
movsd 0x8(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm2
movsd 0xd37(%rip), %xmm1      # 0xf030
divsd %xmm2, %xmm1
callq 0x21d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)