LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosProject::ScanDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>)
void Gos::GosProject::ScanDirectory(std::string directory, std::function<bool(std::string)> filter) {
    std::queue<std::string> imports;
    FileSystem::Iterate(".", std::function([&filter, &imports, this](Path path) {
        if (filter(path.string())) {
            PreprocessFile(path.string(), imports);
        }
    }));
    ExecuteFiles(imports);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0xb075a
leaq 0xe3b2(%rip), %rsi      # 0xbd179
leaq 0x28(%rsp), %rdi
movl $0x2, %edx
callq 0xaf246
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0x11350
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x16c(%rip), %rax       # 0xaef70
movq %rax, 0x18(%rsi)
leaq 0x275(%rip), %rax       # 0xaf084
movq %rax, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0xb1804
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaee34
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x28(%rsp), %rdi
callq 0xaf2ce
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xaea60
leaq 0x50(%rsp), %rdi
callq 0xaf558
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xaee80
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaee8b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaee8b
movq %rax, %rdi
callq 0x26e38
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xaf2ce
jmp 0xaee9a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xaf558
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosFileSystem.cpp
// Function: Gos::FileSystem::Read(std::filesystem::__cxx11::path)
std::stringstream Gos::FileSystem::Read(Path path) {
    std::stringstream ss;
    File& file = instance.files[FileSystem::GetFile(path, false)];
    if (file.packID == -1) {
        std::ifstream fin;
        fin.open(path, std::ios::binary);
        ss << fin.rdbuf();
        fin.close();
    } else {
        std::ifstream fin;
        char* buffer = new char[file.fileSize];
        fin.open(instance.dataPacks[file.packID], std::ios::binary);
        fin.seekg(file.packPos);
        fin.read(buffer, file.fileSize);
        fin.close();
        ss.write(buffer, file.fileSize);
        delete[] buffer;
    }
    return ss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11280
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xaf306
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xb0a48
movslq %eax, %r12
movq 0x6c590(%rip), %r15     # 0x11e410
shlq $0x4, %r12
leaq 0x8(%rsp), %rdi
callq 0xaf2ce
cmpl $-0x1, (%r15,%r12)
je 0xb1f10
leaq 0x30(%rsp), %rdi
callq 0x113b0
addq %r12, %r15
movslq 0x8(%r15), %rdi
callq 0x11030
movq %rax, %r14
movslq (%r15), %rsi
shlq $0x5, %rsi
addq 0x6c53c(%rip), %rsi     # 0x11e3f8
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x11310
movslq 0x4(%r15), %rsi
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0x11400
movslq 0x8(%r15), %rdx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x113f0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x10(%rbx), %rdi
movslq 0x8(%r15), %rdx
movq %r14, %rsi
callq 0x11430
movq %r14, %rdi
callq 0x11420
jmp 0xb1f44
leaq 0x30(%rsp), %rdi
callq 0x113b0
movq (%r14), %rsi
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x11200
leaq 0x10(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x110b0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x30(%rsp), %rdi
callq 0x110d0
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb1f73
jmp 0xb1f73
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xaf2ce
jmp 0xb1f87
movq %rax, %r14
jmp 0xb1f87
jmp 0xb1f7a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x110d0
movq 0x6b00a(%rip), %rsi     # 0x11cf98
movq %rbx, %rdi
callq 0x112c0
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x11120
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/main.cpp
// Function: vmTest(int, char**)
int vmTest(int argc, char* argv[]) {
    reflIO();
    GosVM::RTConst constArea;
    GosVM::VMProgram program(&constArea);
    std::ifstream fin;
    if (argc > 1) {
        fin.open(argv[1]);
    } else {
        fin.open("1.in");
    }
    program.Read(fin, true);
    fin.close();
    // program.Write(std::cout, true);
    auto ret = program.Execute();
    /*
    auto v = refl.New("Virtual");
    v.Invoke("print", {});
    v.GetField("x").As<int>() = 2333;
    v.Invoke("print", {});
    std::cout << v.GetField("x") << std::endl;
    */
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x390, %rsp            # imm = 0x390
movq %rsi, %rbx
movl %edi, %ebp
callq 0xb3284
xorl %eax, %eax
leaq 0xc8(%rsp), %rcx
movq %rax, -0x38(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rcx)
movq %rcx, -0x30(%rcx)
movl $0x1, %edx
movq %rdx, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, %esi       # imm = 0x3F800000
movl %esi, -0x10(%rcx)
leaq 0x118(%rsp), %rcx
movaps %xmm0, -0x58(%rcx)
movaps %xmm0, -0x48(%rcx)
movq %rax, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
movq %rdx, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl %esi, -0x10(%rcx)
movaps %xmm0, -0x8(%rcx)
leaq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x94230
leaq 0x188(%rsp), %rdi
callq 0x113b0
cmpl $0x2, %ebp
jl 0xb377d
movq 0x8(%rbx), %rsi
leaq 0x188(%rsp), %rdi
movl $0x8, %edx
callq 0x11200
jmp 0xb3796
leaq 0x1cb40(%rip), %rsi     # 0xd02c4
leaq 0x188(%rsp), %rdi
movl $0x8, %edx
callq 0x11200
leaq 0x18(%rsp), %rdi
leaq 0x188(%rsp), %rsi
movl $0x1, %edx
callq 0x9669c
leaq 0x188(%rsp), %rdi
callq 0x110a0
leaq 0x128(%rsp), %rdi
callq 0x18afc
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x150(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x128(%rsp), %rdx
callq 0x9459e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb3808
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
leaq 0xe8(%rsp), %rbx
leaq 0x150(%rsp), %rdi
callq 0x1c65c
leaq 0x188(%rsp), %rdi
callq 0x110d0
leaq 0x68627(%rip), %rax     # 0x11be58
addq $0x10, %rax
leaq 0x60(%rsp), %r14
movq %rax, -0x48(%r14)
movq %r14, %rdi
callq 0x26cee
movq -0x28(%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xb3861
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x98(%rsp), %r14
movq %rbx, %rdi
callq 0xaf3aa
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0xb388a
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %r14, %rdi
callq 0xac664
leaq 0x80(%rsp), %rdi
callq 0xaf35c
xorl %eax, %eax
addq $0x390, %rsp            # imm = 0x390
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb38d7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xb38d7
jmp 0xb38d4
movq %rax, %rbx
jmp 0xb38e4
movq %rax, %rbx
jmp 0xb38ee
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x110d0
leaq 0x18(%rsp), %rdi
callq 0xb56ee
leaq 0x80(%rsp), %rdi
callq 0xaf0e8
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/dmarto[P]crrs-xlib/main.cpp
// Function: HandleEvents(_XEvent&, Sphere&, Sphere&)
void HandleEvents(XEvent &event, Sphere &light, Sphere &world)
{
	if (event.type == MotionNotify)
	{
		light.center.x = event.xmotion.x;
		light.center.y = event.xmotion.y;
	}

	if (event.type == ButtonPress && event.xbutton.button == 4 && world.center.z > 580)
	{
		world.center.z -= 5;
		world.center.y -= 5;

		light.center.z -= 30;
	}

	if (event.type == ButtonPress && event.xbutton.button == 5 && world.center.z < 600)
	{
		world.center.z += 5;
		world.center.y += 5;

		light.center.z += 30;
	}
}

// Assembly:
movl (%rdi), %eax
cmpl $0x6, %eax
jne 0x1a24
cvtsi2sdl 0x40(%rdi), %xmm0
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x44(%rdi), %xmm0
movsd %xmm0, 0x8(%rsi)
movl (%rdi), %eax
movl %eax, %r8d
xorl $0x4, %r8d
movl 0x54(%rdi), %ecx
movl %ecx, %r9d
xorl $0x4, %r9d
orl %r8d, %r9d
jne 0x1a7a
movsd 0x10(%rdx), %xmm0
movsd 0x1609(%rip), %xmm1     # 0x3050
ucomisd %xmm0, %xmm1
jae 0x1abf
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x1682(%rip), %xmm1     # 0x30e0
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x15e8(%rip), %xmm0     # 0x3058
movsd %xmm0, 0x10(%rsi)
movl (%rdi), %eax
movl 0x54(%rdi), %ecx
cmpl $0x4, %eax
jne 0x1abf
cmpl $0x5, %ecx
jne 0x1abf
movsd 0x10(%rdx), %xmm0
movsd 0x15cf(%rip), %xmm1     # 0x3060
ucomisd %xmm0, %xmm1
jbe 0x1abf
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x1648(%rip), %xmm1     # 0x30f0
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x15ae(%rip), %xmm0     # 0x3068
movsd %xmm0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/dmarto[P]crrs-xlib/main.cpp
// Function: Sphere::Intersects(Ray const&, double&) const
bool Intersects(const Ray &ray, double &t) const
	{
		const Vec3 origin = ray.origin;
		const Vec3 dest = ray.destination;
		const Vec3 orgCtr = origin - this->center;
		const double b = 2 * dot(orgCtr, dest);
		const double center = dot(orgCtr, orgCtr) - radius * radius;
		double discrim = b * b - 4 * center;

		if (discrim < 1e-4)
			return false;

		discrim = sqrt(discrim);
		const double t0 = -b - discrim;
		const double t1 = -b + discrim;

		t = (t0 < t1) ? t0 : t1;

		return true;
	}

// Assembly:
movsd (%rsi), %xmm0
subsd (%rdi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
movupd 0x8(%rsi), %xmm2
movupd 0x8(%rdi), %xmm3
subpd %xmm3, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
movapd %xmm2, %xmm0
movlpd 0x20(%rsi), %xmm0       # xmm0 = mem[0],xmm0[1]
mulpd %xmm2, %xmm0
addpd %xmm1, %xmm0
movsd 0x18(%rdi), %xmm1
shufpd $0x1, %xmm1, %xmm2      # xmm2 = xmm2[1],xmm1[0]
movsd 0x28(%rsi), %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
mulpd %xmm2, %xmm3
movapd %xmm0, %xmm1
addpd %xmm3, %xmm1
subpd %xmm3, %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
mulpd 0xde7(%rip), %xmm0      # 0x30a0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm2, %xmm1
ucomisd 0xd5b(%rip), %xmm1      # 0x3030
jb 0x22fa
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd 0xdc2(%rip), %xmm3      # 0x30b0
subsd %xmm0, %xmm2
minsd %xmm3, %xmm2
movsd %xmm2, (%rdx)
ucomisd 0xd2e(%rip), %xmm1      # 0x3030
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix(int rows, int cols)
{
  mData = new double* [rows];
  mShape[0] = rows;
  mShape[1] = cols;
	for (int i=0; i<rows;  i++){
		mData[i] = new double[cols];
		for (int j=0; j<cols; j++){
			mData[i][j] = 0.0;
  	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r13d
leaq (,%r13,8), %rdi
testl %esi, %esi
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, (%r14)
movl %ebp, 0x8(%r14)
movl %ebx, 0xc(%r14)
testl %ebp, %ebp
jle 0x2f0d
movl %ebx, %r12d
shlq $0x3, %r12
testl %ebx, %ebx
cmovnsq %r12, %r15
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %ebx, %ebx
jle 0x2f05
movq (%r14), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20a0
incq %rbp
cmpq %rbp, %r13
jne 0x2ee1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::operator()(int, int)
double& Matrix::operator()(int i, int j)
{

  if (i < 1 || j< 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mShape[0] || j >mShape[1] )
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }
  return mData[i-1][j-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
testl %esi, %esi
jle 0x2fa9
testl %edx, %edx
jle 0x2fa9
cmpl %esi, 0x8(%rdi)
jl 0x3028
cmpl %edx, 0xc(%rdi)
jl 0x3028
movq (%rdi), %rax
movl %esi, %ecx
movq -0x8(%rax,%rcx,8), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x60da(%rip), %rsi      # 0x90a0
leaq 0x60df(%rip), %rdx      # 0x90ac
leaq 0x20(%rsp), %rdi
callq 0x8150
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x60c5(%rip), %rsi      # 0x90ad
leaq 0x60eb(%rip), %rdx      # 0x90da
leaq 0x60(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x9d81(%rip), %rsi      # 0xcd98
leaq 0x5108(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
jmp 0x30a1
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6096(%rip), %rsi      # 0x90db
leaq 0x609e(%rip), %rdx      # 0x90ea
movq %rsp, %rdi
callq 0x8150
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6086(%rip), %rsi      # 0x90eb
leaq 0x60ab(%rip), %rdx      # 0x9117
leaq 0x40(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x9d06(%rip), %rsi      # 0xcd98
leaq 0x508d(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x30b3
callq 0x2140
movq (%rsp), %rdi
jmp 0x30d9
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x30f2
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x30d4
callq 0x2140
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x30e3
callq 0x2140
testb %bpl, %bpl
jne 0x3103
jmp 0x310b
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x3103
callq 0x2140
jmp 0x3103
jmp 0x3100
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e94
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x3169
movl 0x8(%r14), %ecx
movq (%r14), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3161
movq (%rsi,%rdi,8), %r8
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x3149
incq %rdi
cmpq %rax, %rdi
jne 0x313e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81e8
cmpl $0x0, 0x8(%r14)
jle 0x31c8
movslq %ebp, %r15
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movsd -0x8(%rax,%r15,8), %xmm0
leal 0x1(%r12), %esi
movq %rbx, %rdi
callq 0x8e60
movslq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x31a1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x827e
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81e8
cmpl $0x0, 0xc(%r14)
jle 0x3234
movslq %ebp, %r15
xorl %r12d, %r12d
movq (%r14), %rax
movq -0x8(%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
leal 0x1(%r12), %esi
movq %rbx, %rdi
callq 0x8e60
movslq 0xc(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x320d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x827e
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movl 0xc(%rsi), %edx
cmpl 0xc(%r12), %edx
jne 0x333c
movq %rsi, %r13
movl 0x8(%rsi), %esi
cmpl 0x8(%r12), %esi
jne 0x333c
movq %rdi, %rbx
callq 0x2e94
movslq 0x8(%rbx), %rbp
leaq (,%rbp,8), %rax
testq %rbp, %rbp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, 0x8(%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %ebp, %ebp
jle 0x3328
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r13), %rcx
movq %rcx, 0x10(%rsp)
movq (%r12), %r12
movl %eax, %ebx
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%r13,8)
testl %ebx, %ebx
jle 0x3320
movq 0x10(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
movq (%r12,%r13,8), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x3309
incq %r13
cmpq %rbp, %r13
jne 0x32ea
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5dd5(%rip), %rdi      # 0x9118
leaq 0x5e07(%rip), %rsi      # 0x9151
leaq 0x5e0b(%rip), %rcx      # 0x915c
movl $0x5f, %edx
callq 0x20b0
jmp 0x335d
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2f1c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2e94
movslq 0x8(%rbx), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, 0x8(%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %r13d, %r13d
jle 0x3429
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r12), %r12
movl %eax, %ebp
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbx,8)
testl %ebp, %ebp
movsd 0x10(%rsp), %xmm1
jle 0x3421
movq (%r12,%rbx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x340b
incq %rbx
cmpq %r13, %rbx
jne 0x33ef
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x343f
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2f1c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3608
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %r13d
cmpl 0xc(%rdi), %r13d
jne 0x3608
testl %r12d, %r12d
jle 0x35f6
movslq %r13d, %rax
shlq $0x3, %rax
testl %r13d, %r13d
movq $-0x1, %r15
cmovnsq %rax, %r15
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
testl %r13d, %r13d
jle 0x35ee
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movq (%rbx), %rcx
movq (%rcx,%rbp,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x35dc
incq %rbp
cmpq %r12, %rbp
jne 0x35b8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5b99(%rip), %rsi      # 0x91be
leaq 0x5b9f(%rip), %rdx      # 0x91cb
leaq 0x8(%rsp), %rdi
callq 0x8150
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5b85(%rip), %rsi      # 0x91cc
leaq 0x5bba(%rip), %rdx      # 0x9208
leaq 0x28(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x9722(%rip), %rsi      # 0xcd98
leaq 0x4aa9(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3697
callq 0x2140
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36a6
callq 0x2140
testb %bpl, %bpl
jne 0x36c4
jmp 0x36cc
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36c4
callq 0x2140
jmp 0x36c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2e94
movslq 0x8(%rbx), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, (%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %r13d, %r13d
jle 0x377f
movq (%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r12), %r12
movl %eax, %ebp
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbx,8)
testl %ebp, %ebp
movaps 0x5905(%rip), %xmm1     # 0x9060
jle 0x3777
movq (%r12,%rbx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x3763
incq %rbx
cmpq %r13, %rbx
jne 0x3746
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3794
movq %rax, %r14
movq (%rsp), %rdi
callq 0x2f1c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38a0
movq %rdx, %r14
movq %rsi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%rdx), %edx
movq %rdi, (%rsp)
callq 0x2e94
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3114
movq %rbx, 0x8(%rsp)
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
jle 0x3883
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl 0xc(%r14), %eax
xorl %ebx, %ebx
leaq 0x38(%rsp), %r12
leaq 0x28(%rsp), %rbp
leaq 0x1(%rbx), %r13
testl %eax, %eax
jle 0x3878
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
movl %r13d, %edx
callq 0x317c
leal 0x1(%r15), %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x317c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x85c5
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq %rbp, %rdi
callq 0x827e
movq %r12, %rdi
callq 0x827e
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jl 0x381b
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movslq %ecx, %rdx
movq %r13, %rbx
cmpq %rdx, %r13
jl 0x3810
leaq 0x18(%rsp), %rdi
callq 0x2f1c
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5962(%rip), %rdi      # 0x9209
leaq 0x58a3(%rip), %rsi      # 0x9151
leaq 0x596f(%rip), %rcx      # 0x9224
movl $0xaa, %edx
callq 0x20b0
movq %rax, %rbx
jmp 0x38ef
movq %rax, %rbx
jmp 0x38db
movq %rax, %rbx
jmp 0x38e5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x827e
leaq 0x38(%rsp), %rdi
callq 0x827e
leaq 0x18(%rsp), %rdi
callq 0x2f1c
movq (%rsp), %rdi
callq 0x2f1c
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d63
cmpl %eax, %ebp
jne 0x39af
movq %r14, %rdi
callq 0x8d63
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x81e8
testl %r12d, %r12d
jle 0x399d
negl %r12d
movl $0x1, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x31e8
movq %r13, %rdi
movq %r14, %rsi
callq 0x85c5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e60
movq %r13, %rdi
callq 0x827e
leal (%r12,%rbp), %eax
incl %eax
movl %ebp, %ecx
incl %ecx
movl %ecx, %ebp
cmpl $0x1, %eax
jne 0x3962
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5893(%rip), %rdi      # 0x9249
leaq 0x5794(%rip), %rsi      # 0x9151
leaq 0x589b(%rip), %rcx      # 0x925f
movl $0xb8, %edx
callq 0x20b0
movq %rax, %r14
jmp 0x39e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x827e
movq %rbx, %rdi
callq 0x827e
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e94
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3a4e
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%r14), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3a46
movq (%rdx,%rdi,8), %r8
movq (%rsi,%rdi,8), %r9
xorl %r10d, %r10d
movsd (%rbx), %xmm0
mulsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3a2e
incq %rdi
cmpq %rax, %rdi
jne 0x3a1f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2e94
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3ac5
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
xorpd %xmm0, %xmm0
testl %ecx, %ecx
jle 0x3abd
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3aa2
jnp 0x3ab5
movsd (%r14), %xmm2
divsd %xmm1, %xmm2
movq (%rsi,%rdi,8), %r10
movsd %xmm2, (%r10,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x3a94
incq %rdi
cmpq %rax, %rdi
jne 0x3a89
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2e94
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3b2c
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3b24
movq (%rdx,%rdi,8), %r8
movq (%rsi,%rdi,8), %r9
xorl %r10d, %r10d
movsd (%r14), %xmm0
mulsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3b0b
incq %rdi
cmpq %rax, %rdi
jne 0x3afc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
jle 0x3be8
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x572a(%rip), %r12      # 0x9284
leaq 0x5725(%rip), %r13      # 0x9286
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x5b1e(%rip), %rsi      # 0x968e
callq 0x2160
cmpl $0x0, 0xc(%r14)
jle 0x3bc4
xorl %ebp, %ebp
movq (%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x21a0
movslq 0xc(%r14), %rax
decq %rax
cmpq %rax, %rbp
jge 0x3bab
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x3bb3
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2160
incq %rbp
movslq 0xc(%r14), %rax
cmpq %rax, %rbp
jl 0x3b7e
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x56b4(%rip), %rsi      # 0x9287
callq 0x2160
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x3b61
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_O3/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 0x2e94
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x3c3b
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rsi,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3c21
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81e8
movl 0xc(%r14), %esi
cmpl %esi, 0x8(%r14)
jle 0x3ca3
leaq 0x8(%rsp), %rdi
callq 0x81e8
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movslq 0xc(%r14), %rcx
cmpq %rcx, %rax
jge 0x3cce
leaq 0x1(%rax), %r12
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %r15, %rdi
movl %r12d, %esi
callq 0x8e60
movq %r12, %rax
jmp 0x3c7a
xorl %eax, %eax
movslq 0x8(%r14), %rcx
cmpq %rcx, %rax
jge 0x3cd8
leaq 0x1(%rax), %r15
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8e60
movq %r15, %rax
jmp 0x3ca5
leaq 0x8(%rsp), %rdi
callq 0x827e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3cf8
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x827e
jmp 0x3cfb
movq %rax, %r14
movq %rbx, %rdi
callq 0x827e
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d63
movl %eax, %r15d
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x2e94
testl %r15d, %r15d
jle 0x3d65
movq (%rbx), %r13
incl %r15d
movl $0x1, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x8abc
movsd (%rax), %xmm0
movq -0x8(%r13,%r12,8), %rax
movsd %xmm0, -0x8(%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x3d42
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f1c
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movl %eax, 0x8(%r14)
movq $-0x1, %rbp
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, (%r14)
movslq 0xc(%rbx), %rax
movl %eax, 0xc(%r14)
movslq 0x8(%rbx), %r12
testq %r12, %r12
jle 0x3e1e
movl %eax, %r13d
movq %rax, %r15
shlq $0x3, %r15
testl %eax, %eax
cmovsq %rbp, %r15
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %r13d, %r13d
jle 0x3e16
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movq (%r14), %rcx
movq (%rcx,%rbp,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x3e04
incq %rbp
cmpq %r12, %rbp
jne 0x3de0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %r15d, %r15d
jle 0x3e8c
leaq 0x1(%r15), %r12
movl $0x1, %r13d
xorl %ebp, %ebp
callq 0x2060
movss 0x5210(%rip), %xmm1     # 0x9070
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0x3e53
incq %r13
cmpq %r12, %r13
jne 0x3e51
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d86
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_O3/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 0x44aa
movq %rsi, %r14
movq %rdi, %rbx
testl %r15d, %r15d
jle 0x448e
incq %r15
movl $0x1, %r12d
xorl %r13d, %r13d
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x4c52(%rip), %xmm0     # 0x9070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x4be9(%rip), %xmm0     # 0x9018
ja 0x4434
xorps %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x4c1a(%rip), %xmm0     # 0x9070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x4bb1(%rip), %xmm0     # 0x9018
ja 0x446c
xorps %xmm0, %xmm0
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, -0x8(%rax,%r12,8)
incq %r13
cmpq %r13, %r12
jne 0x440a
incq %r12
cmpq %r15, %r12
jne 0x4407
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d86
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4dd9(%rip), %rdi      # 0x928a
leaq 0x4c99(%rip), %rsi      # 0x9151
leaq 0x4e1f(%rip), %rcx      # 0x92de
movl $0x16e, %edx            # imm = 0x16E
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movl 0x8(%rsi), %esi
cmpl 0xc(%r14), %esi
jne 0x48b5
movq %rdi, %rbx
callq 0x81e8
movl 0x8(%r14), %esi
leaq 0x18(%rsp), %rdi
callq 0x81e8
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x8e6d
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x893a
movq %rsp, %rdi
callq 0x827e
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x8e6d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x893a
movq %rsp, %r15
movq %r15, %rdi
callq 0x827e
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3915
movq %rbx, %rdi
movq %r15, %rsi
callq 0x893a
movq %r15, %rdi
callq 0x827e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x85c5
movsd %xmm0, 0x30(%rsp)
movq %r12, %rdi
movl $0x2, %esi
callq 0x8d68
movsd %xmm0, 0x28(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8d68
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x8758
movq %rbx, %rdi
movq %r15, %rsi
callq 0x893a
movq %r15, %rdi
callq 0x827e
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8428
movq %r15, %rdi
movl $0x2, %esi
callq 0x8d68
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x827e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x893a
xorps %xmm0, %xmm0
cvtsd2ss 0x38(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd 0x4847(%rip), %xmm0     # 0x9088
ja 0x477f
movsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
seta %cl
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
leaq 0x10(%rsp), %rdx
movsd %xmm0, (%rdx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x864a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x893a
movq %rsp, %rdi
callq 0x827e
leaq 0x18(%rsp), %rdi
callq 0x827e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4a5e(%rip), %rdi      # 0x931a
leaq 0x488e(%rip), %rsi      # 0x9151
leaq 0x4a65(%rip), %rcx      # 0x932f
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x20b0
jmp 0x48ed
jmp 0x48fc
jmp 0x48ed
jmp 0x48fc
jmp 0x48ed
jmp 0x48fc
movq %rax, %r14
jmp 0x4909
jmp 0x48fc
jmp 0x48ed
jmp 0x48ed
jmp 0x48fc
movq %rax, %r14
movq %rsp, %rdi
callq 0x827e
jmp 0x48ff
jmp 0x48fc
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x827e
movq %rbx, %rdi
callq 0x827e
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %ebx
shlq $0x3, %rbx
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rbx, %rdi
callq 0x2030
movq %rax, (%r14)
movl %ebp, 0x8(%r14)
testl %ebp, %ebp
jle 0x8225
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x20a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%r14)
testq %r15, %r15
jle 0x8277
movq (%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x8265
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %edx
movl 0x8(%rsi), %ebp
cmpl %ebp, %edx
jg 0x85e0
movl %edx, %ebp
jge 0x8611
movq 0x4a09(%rip), %r15      # 0xcff0
leaq 0xfaa(%rip), %rsi       # 0x9598
movl $0x2b, %edx
movq %r15, %rdi
callq 0x2160
leaq 0xf36(%rip), %rsi       # 0x9538
movl $0x32, %edx
movq %r15, %rdi
callq 0x2160
movl %ebp, %edx
testl %edx, %edx
jle 0x863b
movq (%r14), %rax
movq (%rbx), %rcx
movl %edx, %edx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x8623
jmp 0x863f
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
leaq (,%rbp,8), %r13
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testl %ebp, %ebp
jle 0x86bf
movq %rax, %r12
movq %r15, (%rsp)
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20a0
movq (%rsp), %rax
movsd (%rax), %xmm0
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r12,%r15,8)
incq %r15
cmpq %r15, %rbp
jne 0x86a7
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x8(%rdx), %ebp
leaq (,%rbp,8), %r13
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testl %ebp, %ebp
jle 0x8746
movq %rax, %r15
movq %r12, (%rsp)
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20a0
movq (%rsp), %rax
movsd (%rax), %xmm0
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15,%r12,8)
incq %r12
cmpq %r12, %rbp
jne 0x872e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq