LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: agorenst[P]trie/./prefixtree.h
// Function: prefix_tree<int>::node::tikz_print(std::ostream&)
void tikz_print(std::ostream& o) {
            o << "node[circle, draw]{}" << std::endl;
            for (auto it = edges.begin(); it != edges.end(); ++it) {
                o << "child {" << std::endl;
                it->second->tikz_print(o);
                o << "edge from parent node[left]{" << it->first << "}" << std::endl;
                o << "}" << std::endl;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x733(%rip), %rsi       # 0x60e6
callq 0x2110
movq %rax, %rdi
movq 0x45f6(%rip), %rsi      # 0x9fb8
callq 0x2140
movq -0x28(%rbp), %rdi
callq 0x5ab0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x45f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5ae0
testb $0x1, %al
jne 0x59f7
jmp 0x5aaa
movq -0x10(%rbp), %rdi
leaq 0x6f9(%rip), %rsi       # 0x60fb
callq 0x2110
movq %rax, %rdi
movq 0x45a7(%rip), %rsi      # 0x9fb8
callq 0x2140
leaq -0x18(%rbp), %rdi
callq 0x5b10
movq %rax, %rdi
addq $0x8, %rdi
callq 0x4300
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5990
movq -0x10(%rbp), %rdi
leaq 0x6c1(%rip), %rsi       # 0x6103
callq 0x2110
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5b10
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x21d0
movq %rax, %rdi
leaq 0x65d(%rip), %rsi       # 0x60c6
callq 0x2110
movq %rax, %rdi
movq 0x4540(%rip), %rsi      # 0x9fb8
callq 0x2140
movq -0x10(%rbp), %rdi
leaq 0x63e(%rip), %rsi       # 0x60c6
callq 0x2110
movq %rax, %rdi
movq 0x4521(%rip), %rsi      # 0x9fb8
callq 0x2140
leaq -0x18(%rbp), %rdi
callq 0x5700
jmp 0x59d4
addq $0x30, %rsp
popq %rbp
retq
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::operator()(int) const
const double& Vector::operator()(int i) const
{

  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 0x3d82
movb $0x1, 0x8e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x20(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x21c0
movq 0x28(%rsp), %rdx
leaq 0xe547(%rip), %rsi      # 0x121bd
leaq 0xc8(%rsp), %rdi
callq 0x2110
jmp 0x3c85
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21c0
movq 0x18(%rsp), %rdx
leaq 0xe527(%rip), %rsi      # 0x121ca
leaq 0x90(%rsp), %rdi
callq 0x2110
jmp 0x3cb2
movq 0x20(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x4d60
jmp 0x3cce
movq 0x20(%rsp), %rdi
movb $0x0, 0x8e(%rsp)
leaq 0x120be(%rip), %rsi     # 0x15da0
leaq 0x1047(%rip), %rdx      # 0x4d30
callq 0x2180
jmp 0x3edf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x3d5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x3d40
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 0x20f0
leaq 0xc8(%rsp), %rdi
callq 0x2080
leaq 0xc7(%rsp), %rdi
callq 0x20f0
testb $0x1, 0x8e(%rsp)
jne 0x3d73
jmp 0x3d7d
movq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x3ed2
movq 0x30(%rsp), %rcx
movl 0xec(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0x3eac
movb $0x1, 0x3e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x8(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21c0
movq 0x10(%rsp), %rdx
leaq 0xe34e(%rip), %rsi      # 0x12114
leaq 0x68(%rsp), %rdi
callq 0x2110
jmp 0x3dd2
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21c0
movq (%rsp), %rdx
leaq 0xe40d(%rip), %rsi      # 0x121f8
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x3df7
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x4d60
jmp 0x3e0d
movq 0x8(%rsp), %rdi
movb $0x0, 0x3e(%rsp)
leaq 0x11f82(%rip), %rsi     # 0x15da0
leaq 0xf0b(%rip), %rdx       # 0x4d30
callq 0x2180
jmp 0x3edf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x3e8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x3e79
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 0x20f0
leaq 0x68(%rsp), %rdi
callq 0x2080
leaq 0x67(%rsp), %rdi
callq 0x20f0
testb $0x1, 0x3e(%rsp)
jne 0x3ea0
jmp 0x3eaa
movq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x3ed2
jmp 0x3eae
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 0x21b0
nop
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: linspace(double, double, int)
Vector linspace(double start, double end, int points)
{
  Vector out(points);
  double len = end - start;
  double interval = (len*1.0)/(points-1);
  out(1) = start;
  out(points) = end;
  for (int i=2;i<points;i++)
  {
      out(i) = start + ((i-1)*interval);
  }
  return out;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movsd %xmm1, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movb $0x0, 0x6b(%rsp)
movl 0x6c(%rsp), %esi
callq 0x2d70
movq 0x30(%rsp), %rdi
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x6c(%rsp), %eax
decl %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x1, %esi
callq 0x3ee0
movq %rax, 0x40(%rsp)
jmp 0x41dc
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x6c(%rsp), %esi
callq 0x3ee0
movq %rax, 0x20(%rsp)
jmp 0x420c
movq 0x20(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x2, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x429a
movq 0x30(%rsp), %rdi
movsd 0x78(%rsp), %xmm1
movl 0x48(%rsp), %esi
movl %esi, %eax
decl %eax
cvtsi2sd %eax, %xmm0
movsd 0x58(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3ee0
movq %rax, 0x10(%rsp)
jmp 0x4264
movq 0x10(%rsp), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x4223
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2ea0
jmp 0x42bd
movb $0x1, 0x6b(%rsp)
testb $0x1, 0x6b(%rsp)
jne 0x42b0
movq 0x30(%rsp), %rdi
callq 0x2ea0
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x21b0
nopw (%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: reshape(Vector&, int, int)
Matrix reshape(Vector& u, int rows, int cols)
{
  if (length(u) != rows*cols)
	{
		  throw Exception("dimension mismatch",
			  "number of elements in vector not equal to entries in output matrix");
	}

  Matrix out(rows,cols);
  int count =1;
  for (int j = 1;j<=cols;j++)
  {
    for (int i = 1; i<=rows; i++)
    {
        out(i,j) = u(count);
        count++;
    }
  }
  return out;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movl %ecx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x4090
movl 0xb4(%rsp), %ecx
imull 0xb0(%rsp), %ecx
cmpl %ecx, %eax
je 0x4446
movb $0x1, 0x56(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x28(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x21c0
movq 0x30(%rsp), %rdx
leaq 0xded0(%rip), %rsi      # 0x12228
leaq 0x90(%rsp), %rdi
callq 0x2110
jmp 0x4367
leaq 0x57(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x21c0
movq 0x20(%rsp), %rdx
leaq 0xdeb9(%rip), %rsi      # 0x1223b
leaq 0x58(%rsp), %rdi
callq 0x2110
jmp 0x438e
movq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x4d60
jmp 0x43a7
movq 0x28(%rsp), %rdi
movb $0x0, 0x56(%rsp)
leaq 0x119e8(%rip), %rsi     # 0x15da0
leaq 0x971(%rip), %rdx       # 0x4d30
callq 0x2180
jmp 0x4563
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x4421
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x440a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2080
leaq 0x57(%rsp), %rdi
callq 0x20f0
leaq 0x90(%rsp), %rdi
callq 0x2080
leaq 0x8f(%rsp), %rdi
callq 0x20f0
testb $0x1, 0x56(%rsp)
jne 0x4437
jmp 0x4441
movq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x4556
movq 0x38(%rsp), %rdi
movb $0x0, 0x55(%rsp)
movl 0xb4(%rsp), %esi
movl 0xb0(%rsp), %edx
callq 0x4e80
movl $0x1, 0x50(%rsp)
movl $0x1, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0xb0(%rsp), %eax
jg 0x4533
movl $0x1, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jg 0x4521
movq 0xb8(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x3ee0
movq %rax, 0x18(%rsp)
jmp 0x44b5
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x48(%rsp), %esi
movl 0x4c(%rsp), %edx
callq 0x96e0
movq %rax, 0x10(%rsp)
jmp 0x44dd
movq 0x10(%rsp), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x448c
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x5230
jmp 0x4556
jmp 0x4523
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4473
movb $0x1, 0x55(%rsp)
testb $0x1, 0x55(%rsp)
jne 0x4549
movq 0x38(%rsp), %rdi
callq 0x5230
movq 0x40(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: ones(int)
Vector ones(int length)
{
    Vector out(length);
    for (int i = 1; i<=length;i++)
    {
      out(i) = 1;
    }
    return out;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movb $0x0, 0x3b(%rsp)
movl 0x3c(%rsp), %esi
callq 0x2d70
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jg 0x45f7
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x3ee0
movq %rax, 0x8(%rsp)
jmp 0x45bf
movq 0x8(%rsp), %rax
movsd 0xda44(%rip), %xmm0     # 0x12010
movsd %xmm0, (%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x45a0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x2ea0
jmp 0x4617
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0x460d
movq 0x10(%rsp), %rdi
callq 0x2ea0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::getValues(int, int) const
Vector Vector::getValues(int i,int j) const
{
	int l = j-i+1;
	Vector splice(l);
	for (int k = 1; k<=l; k++)
	{
		splice.mData[k-1] = mData[k-1];
	}
	return splice;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
subl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
movl 0x2c(%rsp), %esi
callq 0x2d70
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x46c7
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movl 0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4682
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x46dd
movq 0x8(%rsp), %rdi
callq 0x2ea0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::setValue(int, int) const
void Vector::setValue(int loc, int set) const
{
	if (loc < 1)
		{
		  throw Exception("out of range",
			  "accessing vector through () - index too small");
		}
	else if (loc > mSize)
		{
		  throw Exception("length mismatch",
			  "accessing vector through () - index too high");
		}

			mData[loc-1] = set;

}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movl %edx, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x1, 0xec(%rsp)
jge 0x4bc9
movb $0x1, 0x8e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x20(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x21c0
movq 0x28(%rsp), %rdx
leaq 0xd700(%rip), %rsi      # 0x121bd
leaq 0xc8(%rsp), %rdi
callq 0x2110
jmp 0x4acc
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21c0
movq 0x18(%rsp), %rdx
leaq 0xd6e0(%rip), %rsi      # 0x121ca
leaq 0x90(%rsp), %rdi
callq 0x2110
jmp 0x4af9
movq 0x20(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x4d60
jmp 0x4b15
movq 0x20(%rsp), %rdi
movb $0x0, 0x8e(%rsp)
leaq 0x11277(%rip), %rsi     # 0x15da0
leaq 0x200(%rip), %rdx       # 0x4d30
callq 0x2180
jmp 0x4d2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x4ba1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x4b87
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 0x20f0
leaq 0xc8(%rsp), %rdi
callq 0x2080
leaq 0xc7(%rsp), %rdi
callq 0x20f0
testb $0x1, 0x8e(%rsp)
jne 0x4bba
jmp 0x4bc4
movq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x4d20
movq 0x30(%rsp), %rcx
movl 0xec(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0x4cf3
movb $0x1, 0x3e(%rsp)
movl $0x40, %edi
callq 0x2070
movq %rax, 0x8(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21c0
movq 0x10(%rsp), %rdx
leaq 0xd507(%rip), %rsi      # 0x12114
leaq 0x68(%rsp), %rdi
callq 0x2110
jmp 0x4c19
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21c0
movq (%rsp), %rdx
leaq 0xd5c6(%rip), %rsi      # 0x121f8
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x4c3e
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x4d60
jmp 0x4c54
movq 0x8(%rsp), %rdi
movb $0x0, 0x3e(%rsp)
leaq 0x1113b(%rip), %rsi     # 0x15da0
leaq 0xc4(%rip), %rdx        # 0x4d30
callq 0x2180
jmp 0x4d2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x4cd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x4cc0
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 0x20f0
leaq 0x68(%rsp), %rdi
callq 0x2080
leaq 0x67(%rsp), %rdi
callq 0x20f0
testb $0x1, 0x3e(%rsp)
jne 0x4ce7
jmp 0x4cf1
movq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x4d20
jmp 0x4cf5
movq 0x30(%rsp), %rax
cvtsi2sdl 0xe8(%rsp), %xmm0
movq (%rax), %rax
movl 0xec(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0xf8, %rsp
retq
movq 0xb8(%rsp), %rdi
callq 0x21b0
nopl (%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix(int i, int j)
{
	mRows = i;
	mColumns = j;
	mElements = new double*[i];

	for (int k = 0; k<i; k++)
	{
		mElements[k]= new double[j];
		for (int l = 0; l<j; l++)
		{
			mElements[k][l] = 0;
		}
	}
	// std::cout<<"constructor called\n";
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
movslq 0x1c(%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 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x4f79
movslq 0x18(%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, %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
cmpl 0x18(%rsp), %eax
jge 0x4f67
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4f32
jmp 0x4f69
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ee2
addq $0x28, %rsp
retq
nop
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(int, int, std::initializer_list<double>)
Matrix::Matrix(int i, int j, std::initializer_list<double> entries)
{

	mRows = i;
	mColumns = j;
	mElements = new double*[i];
	int count = 0;
	int len = entries.size();
	for (int k = 0; k<i; k++)
	{
		mElements[k]= new double[j];
		for (int l = 0; l<j; l++)
		{
			if (count<len){ mElements[k][l] = entries.begin()[count];}
			else {mElements[k][l] = 0.0;}
			count+=1;
		}
	}

}

// Assembly:
subq $0x38, %rsp
movq %rcx, 0x28(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
movslq 0x1c(%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 $0x0, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x10d70
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x50dd
movslq 0x18(%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, %rdx
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x50cb
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x5096
leaq 0x28(%rsp), %rdi
callq 0x10d80
movq %rax, %rcx
movq (%rsp), %rax
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x50b3
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x504f
jmp 0x50cd
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5000
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& original)
{
  mRows = original.mRows;
  mColumns = original.mColumns;
  mElements= new double*[mRows];
  for (int k = 0; k<mRows; k++)
  {
	  mElements[k]= new double[mColumns];
  }
  for (int k = 0; k<mRows; k++)
  {
	  for (int l = 0; l<mColumns; l++)
	  {
		  mElements[k][l] = original.mElements[k][l];
	  }
  }
	// std::cout<<"copy constructor called\n";
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%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 (%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
movq (%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x51aa
movq (%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 (%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5154
movl $0x0, 0x10(%rsp)
movq (%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5225
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x5216
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x51c7
jmp 0x5218
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x51b2
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& output, const Matrix& A)
{
	for (int i=0; i<A.mRows; i++)
	{
		output << "[ ";
		for (int j = 0; j<A.mColumns; j++)
			{
				output <<  A.mElements[i][j];
				if (j != A.mColumns-1)
					output  << "  ";
				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 0x5405
movq 0x10(%rsp), %rdi
leaq 0xcf8c(%rip), %rsi      # 0x122f0
callq 0x20e0
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x53e4
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 0x21d0
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x53c6
movq 0x10(%rsp), %rdi
leaq 0xcf34(%rip), %rsi      # 0x122f3
callq 0x20e0
jmp 0x53d7
movq 0x10(%rsp), %rdi
leaq 0xcf24(%rip), %rsi      # 0x122f6
callq 0x20e0
jmp 0x53d9
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x5370
movq 0x10(%rsp), %rdi
leaq 0xceba(%rip), %rsi      # 0x122aa
callq 0x20e0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5346
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator+(Matrix const&, Matrix const&)
Matrix operator+(const Matrix& A, const Matrix& B)
{
	assert(EqualDim(A,B));
	int i = A.mRows;
	int j = A.mColumns;
	Matrix ans(i,j);
	for (int k=0;k<i;k++)
	{
		for (int l=0;l<j;l++)
		{
			ans.mElements[k][l] = A.mElements[k][l] + B.mElements[k][l];
		}
	}
	return ans;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x52b0
testb $0x1, %al
jne 0x6955
jmp 0x6957
jmp 0x6976
leaq 0xba55(%rip), %rdi      # 0x123b3
leaq 0xba5c(%rip), %rsi      # 0x123c1
movl $0x112, %edx            # imm = 0x112
leaq 0xba5b(%rip), %rcx      # 0x123cc
callq 0x2090
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x4e80
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x6a3d
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x6a2b
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x1c(%rsp), %rdx
addsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x69c3
jmp 0x6a2d
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x69ad
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x6a53
movq 0x8(%rsp), %rdi
callq 0x5230
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator*(double, Matrix const&)
Matrix operator*(double c, const Matrix& A)
{
	Matrix ans(A.mRows, A.mColumns);
	for (int i=0; i<A.mRows; i++)
	{
		for (int j=0; j< A.mColumns; j++)
		{
			ans.mElements[i][j] = c * A.mElements[i][j];
		}
	}
	return ans;

}

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x20(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x4e80
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6c5d
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6c4e
movq (%rsp), %rax
movsd 0x28(%rsp), %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 0x6bf8
jmp 0x6c50
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6be2
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x6c72
movq (%rsp), %rdi
callq 0x5230
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator/(Matrix const&, Vector const&)
Vector operator/(const Matrix& A, const Vector& b)
{
	boost::tuple<Matrix, Matrix, Matrix> LUP = LU(A);
	Matrix L = LUP.get<0>();
	Matrix U = LUP.get<1>();
	Matrix P = LUP.get<2>();
	Vector newb = P*b;
	Vector y = forwardsubst(L,newb);
	Vector x = backsubst(U,y);
	return x;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd8(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x7aa0
movq 0x28(%rsp), %rdi
callq 0x10dd0
movq %rax, 0x30(%rsp)
jmp 0x7897
movq 0x30(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x50f0
jmp 0x78ab
leaq 0xa0(%rsp), %rdi
callq 0x10de0
movq %rax, 0x10(%rsp)
jmp 0x78bf
movq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x50f0
jmp 0x78d0
leaq 0xa0(%rsp), %rdi
callq 0x10df0
movq %rax, 0x8(%rsp)
jmp 0x78e4
movq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x50f0
jmp 0x78f5
movq 0xd0(%rsp), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6f70
jmp 0x790e
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x8950
jmp 0x7927
movq 0x18(%rsp), %rdi
movb $0x0, 0x3f(%rsp)
leaq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
callq 0x8dc0
jmp 0x7944
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x79fd
jmp 0x79f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7a77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7a6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7a60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2ea0
jmp 0x7a4c
movq 0x18(%rsp), %rdi
callq 0x2ea0
leaq 0x40(%rsp), %rdi
callq 0x2ea0
leaq 0x50(%rsp), %rdi
callq 0x2ea0
leaq 0x60(%rsp), %rdi
callq 0x5230
leaq 0x70(%rsp), %rdi
callq 0x5230
leaq 0x90(%rsp), %rdi
callq 0x5230
leaq 0xa0(%rsp), %rdi
callq 0x10e00
movq 0x20(%rsp), %rax
addq $0xe8, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x2ea0
leaq 0x60(%rsp), %rdi
callq 0x5230
leaq 0x70(%rsp), %rdi
callq 0x5230
leaq 0x90(%rsp), %rdi
callq 0x5230
leaq 0xa0(%rsp), %rdi
callq 0x10e00
movq 0x88(%rsp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator!(Matrix const&)
Matrix operator!(const Matrix& A)
{
	Matrix T(A.mColumns, A.mRows);
	for (int i=0;i<A.mRows; i++)
	{
		for (int j=0; j<A.mColumns; j++)
		{
			T(j+1,i+1) = A.mElements[i][j];
		}
	}
	return T;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
movq 0x48(%rsp), %rax
movl 0xc(%rax), %esi
movq 0x48(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x4e80
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x97f7
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x97e5
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rax
movslq 0x40(%rsp), %rcx
movl %ecx, %edx
movq (%rax,%rcx,8), %rax
movslq 0x3c(%rsp), %rcx
movl %ecx, %esi
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
incl %esi
incl %edx
callq 0x96e0
movq %rax, 0x10(%rsp)
jmp 0x97af
movq 0x10(%rsp), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9767
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x5230
jmp 0x9817
jmp 0x97e7
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x974d
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x980d
movq 0x18(%rsp), %rdi
callq 0x5230
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator-(Matrix const&)
Matrix operator-(const Matrix& A)
{
  Matrix ans(A.mRows, A.mColumns);

  for (int i=0; i<A.mRows; i++)
  {
	  for (int j=0; j< A.mColumns; j++)
	  {
		  ans.mElements[i][j] = -A.mElements[i][j];
	  }
  }
  return ans;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x4e80
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x9901
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x98ef
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x1c(%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 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9887
jmp 0x98f1
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x986d
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x9917
movq 0x8(%rsp), %rdi
callq 0x5230
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::operator=(Matrix const&)
Matrix& Matrix::operator=(const Matrix& A)

{
	assert(EqualDim(*this,A));

	for (int i=0; i<A.mRows; i++)
	{
		for (int j=0; j< A.mColumns; j++)
		{
			mElements[i][j] = A.mElements[i][j];
		}
	}
	return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x52b0
testb $0x1, %al
jne 0x9958
jmp 0x995a
jmp 0x9979
leaq 0x8b5e(%rip), %rdi      # 0x124bf
leaq 0x8a59(%rip), %rsi      # 0x123c1
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x8b5d(%rip), %rcx      # 0x124d1
callq 0x2090
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x99f7
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x99e8
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 0x9997
jmp 0x99ea
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9981
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: outer(Vector, Vector)
Matrix outer(Vector u, Vector v)
{
	int l1 = length(u); int l2 =length(v);
	Matrix ans(l1, l2);
	for (int i=0;i<l1;i++)
	{
		for(int j=0;j<l2;j++)
		{
			ans.mElements[i][j] = u(i+1)*v(j+1);
		}
	}
	return ans;
}

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rax, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
callq 0x4090
movq 0x28(%rsp), %rdi
movl %eax, 0x5c(%rsp)
callq 0x4090
movq 0x30(%rsp), %rdi
movl %eax, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
callq 0x4e80
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x9c7a
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x9c68
movq 0x18(%rsp), %rdi
movl 0x50(%rsp), %esi
incl %esi
callq 0x3ee0
movq %rax, 0x10(%rsp)
jmp 0x9bf3
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl 0x4c(%rsp), %esi
incl %esi
callq 0x3ee0
movq %rax, 0x8(%rsp)
jmp 0x9c18
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rsp), %xmm0
mulsd (%rcx), %xmm0
movq (%rax), %rax
movslq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x4c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x9bce
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x5230
jmp 0x9c9a
jmp 0x9c6a
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x9bb8
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x9c90
movq 0x30(%rsp), %rdi
callq 0x5230
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: size(Matrix const&)
Vector size(const Matrix& A)
{
	Vector dimensions(2);
	dimensions(1) = A.mRows;
	dimensions(2) = A.mColumns;
	return dimensions;
}

// 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)
movl $0x2, %esi
callq 0x2d70
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x1, %esi
callq 0x3ee0
movq %rax, 0x28(%rsp)
jmp 0xa180
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x48(%rsp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, (%rsp)
movl $0x2, %esi
callq 0x3ee0
movq %rax, 0x8(%rsp)
jmp 0xa1b4
movq 0x8(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xa1f4
jmp 0xa1ea
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2ea0
jmp 0xa1fe
movq 0x18(%rsp), %rdi
callq 0x2ea0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: eye(int)
Matrix eye(int i)
{
	Matrix I(i,i);
	for (int k=0;k<i;k++)
	{
		I.mElements[k][k] = 1;
	}
	return I;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movb $0x0, 0x1b(%rsp)
movl 0x1c(%rsp), %esi
movl 0x1c(%rsp), %edx
callq 0x4e80
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xa27c
movq (%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd 0x7da6(%rip), %xmm0     # 0x12010
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa243
movb $0x1, 0x1b(%rsp)
testb $0x1, 0x1b(%rsp)
jne 0xa291
movq (%rsp), %rdi
callq 0x5230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: diag(Vector const&)
Matrix diag(const Vector& v)
{
	Matrix D(length(v), length(v));
	for (int k=0;k<length(v);k++)
	{
		D.mElements[k][k] = v(k+1);
	}
	return D;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4090
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4090
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %eax, %edx
callq 0x4e80
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4090
movl %eax, 0xc(%rsp)
jmp 0xa308
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0xa374
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
incl %esi
callq 0x3c10
movq %rax, (%rsp)
jmp 0xa32a
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movsd (%rcx), %xmm0
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x30(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xa2f0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5230
jmp 0xa394
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xa38a
movq 0x18(%rsp), %rdi
callq 0x5230
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x21b0
nop
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: diag(Vector const&, int)
Matrix diag(const Vector& v, int i) // lets you specify which diagonal to put the vector on
{
	int dim = length(v)+abs(i);
	Matrix D(dim, dim);
	if (i==0) {return diag(v);}
	else if (i>0) {
		for (int k=0;k<length(v);k++)
		{
			D.mElements[k][k+i] = v(k+1);
		}
	}
	else if (i<0)	{
		for (int k=0;k<length(v);k++)
		{
			D.mElements[k-i][k] = v(k+1);
		}
	}
	//std::cout<<"This comes form inside 2\n"<<D<<"\n";
	return D;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4090
movl 0x64(%rsp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl %ecx, %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %esi
movl 0x60(%rsp), %edx
leaq 0x50(%rsp), %rdi
callq 0x4e80
cmpl $0x0, 0x64(%rsp)
jne 0xa42e
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xa2a0
jmp 0xa404
movl $0x1, 0x40(%rsp)
jmp 0xa54e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5230
jmp 0xa562
cmpl $0x0, 0x64(%rsp)
jle 0xa4b1
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4090
movl %eax, 0x24(%rsp)
jmp 0xa455
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0xa4ac
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %esi
incl %esi
callq 0x3c10
movq %rax, 0x18(%rsp)
jmp 0xa478
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x50(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x3c(%rsp), %ecx
addl 0x64(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xa43d
jmp 0xa533
cmpl $0x0, 0x64(%rsp)
jge 0xa531
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4090
movl %eax, 0x14(%rsp)
jmp 0xa4d8
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0xa52f
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
incl %esi
callq 0x3c10
movq %rax, 0x8(%rsp)
jmp 0xa4fb
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x50(%rsp), %rax
movl 0x38(%rsp), %ecx
subl 0x64(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq 0x38(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0xa4c0
jmp 0xa531
jmp 0xa533
jmp 0xa535
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x50f0
jmp 0xa546
movl $0x1, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5230
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x21b0
nopl (%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: diag(Matrix const&)
Vector diag(const Matrix& A)
{
	int r =  A.mRows; int c = A.mColumns;
	int l = std::max(r,c);
	Vector diagonal(l);
	for (int i=0;i<l;i++)
	{
		diagonal(i+1) = A.mElements[i][i]; //vectors are also indexed in this notation from 1 not 0, given the overloaded index operator in the Vector class
	}
	return diagonal;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x40(%rsp)
leaq 0x44(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10d90
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movb $0x0, 0x3b(%rsp)
movl 0x3c(%rsp), %esi
callq 0x2d70
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0xa642
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rax
movslq 0x34(%rsp), %rcx
movl %ecx, %esi
movq (%rax,%rcx,8), %rax
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
incl %esi
callq 0x3ee0
movq %rax, 0x8(%rsp)
jmp 0xa60d
movq 0x8(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xa5d3
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x2ea0
jmp 0xa662
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0xa658
movq 0x18(%rsp), %rdi
callq 0x2ea0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x21b0
nopl (%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: givens(double, double)
std::pair <double, double> givens(double a, double b)
{
	double r = sqrt((a*a) + (b*b));
	double c = a/r; double s = -b/r;
	std::pair <double,double> giv = std::make_pair(c,s);
	return giv;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
callq 0x20b0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movaps 0x6300(%rip), %xmm1     # 0x122e0
movsd 0x18(%rsp), %xmm0
pxor %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10ff0
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::applygivens(int, int, double, double)
void Matrix:: applygivens(int i, int j, double c, double s)
{
	for (int k = 1; k<=mColumns; k++)
	{
		double newi = c*mElements[i-1][k-1] - s*mElements[j-1][k-1];
		double newj = s*mElements[i-1][k-1] + c*mElements[j-1][k-1];
		mElements[i-1][k-1] = newi; mElements[j-1][k-1] = newj;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movl $0x1, -0x24(%rsp)
movq -0x40(%rsp), %rcx
movl -0x24(%rsp), %eax
cmpl 0xc(%rcx), %eax
jg 0xc199
movq -0x40(%rsp), %rax
movsd -0x18(%rsp), %xmm0
movq (%rax), %rcx
movl -0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd -0x20(%rsp), %xmm1
movq (%rax), %rcx
movl -0x10(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
mulsd (%rcx,%rdx,8), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rsp)
movsd -0x20(%rsp), %xmm0
movq (%rax), %rcx
movl -0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd -0x18(%rsp), %xmm1
movq (%rax), %rcx
movl -0x10(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
mulsd (%rcx,%rdx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x30(%rsp), %xmm0
movq (%rax), %rcx
movl -0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd %xmm0, (%rcx,%rdx,8)
movsd -0x38(%rsp), %xmm0
movq (%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xc05b
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/prec.cc
// Function: main
int main()
{
	// cout.precision reports the current precision value
	cout  << "Precision: " << cout.precision()  
	      << ", Value: "   << sqrt(2.0) << endl;
	
	// cout.precision(12) asks that 12 digits of precision be printed
	cout.precision(12);
	cout << "Precision: " << cout.precision() 
	     << ", Value: "   << sqrt(2.0) << endl;
	
	// alternative way to set precision using the setprecision manipulator
	cout << setprecision(3);
	cout << "Precision: " << cout.precision() 
	     << ", Value: "   << sqrt(2.0) << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dd2(%rip), %rdi      # 0x3fd8
leaq 0xe03(%rip), %rsi       # 0x2010
callq 0x1050
movq %rax, -0x38(%rbp)
movq 0x2dbb(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq 0x2db1(%rip), %rdi      # 0x3fd8
addq -0x18(%rax), %rdi
callq 0x13b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x1090
movq %rax, %rdi
leaq 0xdd6(%rip), %rsi       # 0x201c
callq 0x1050
movq %rax, -0x30(%rbp)
movsd 0xdb1(%rip), %xmm0      # 0x2008
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
movq 0x2d59(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2d5d(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq 0x2d53(%rip), %rdi      # 0x3fd8
addq -0x18(%rax), %rdi
movl $0xc, %esi
callq 0x13d0
movq 0x2d3e(%rip), %rdi      # 0x3fd8
leaq 0xd6f(%rip), %rsi       # 0x2010
callq 0x1050
movq %rax, -0x28(%rbp)
movq 0x2d27(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq 0x2d1d(%rip), %rdi      # 0x3fd8
addq -0x18(%rax), %rdi
callq 0x13b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1090
movq %rax, %rdi
leaq 0xd42(%rip), %rsi       # 0x201c
callq 0x1050
movq %rax, -0x20(%rbp)
movsd 0xd1d(%rip), %xmm0      # 0x2008
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
movq 0x2cc5(%rip), %rsi      # 0x3fc8
callq 0x1060
movl $0x3, %edi
callq 0x1400
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
movq 0x2cb9(%rip), %rdi      # 0x3fd8
callq 0x1080
movq 0x2cad(%rip), %rdi      # 0x3fd8
leaq 0xcde(%rip), %rsi       # 0x2010
callq 0x1050
movq %rax, -0x18(%rbp)
movq 0x2c96(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq 0x2c8c(%rip), %rdi      # 0x3fd8
addq -0x18(%rax), %rdi
callq 0x13b0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1090
movq %rax, %rdi
leaq 0xcb1(%rip), %rsi       # 0x201c
callq 0x1050
movq %rax, -0x10(%rbp)
movsd 0xc8c(%rip), %xmm0      # 0x2008
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
movq 0x2c34(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)