LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Convdown(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
std::vector<T> Wavelet<T>::Convdown(const std::vector<T>& x, const std::vector<T>& f) const {
  const size_t last = static_cast<size_t>(std::ceil(static_cast<double>(x.size()) / 2.0) * 2.0);
  std::vector<T> z = Wextend(x, half_length_filter_);
  z = Conv(z, f, kValidConvolution);
  std::vector<T> y(last / 2);
  for (size_t k = 1; k <= last; k += 2) {
    // Since k is always an odd integer, k/2 === floor(k/2)
    y[k / 2] = z[k];
  }
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %xmm0
movaps 0xc2e7(%rip), %xmm1     # 0x12130
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc2eb(%rip), %xmm1     # 0x12140
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xc2e4(%rip), %xmm1     # 0x12150
mulsd %xmm1, %xmm0
callq 0x2050
movq -0x80(%rbp), %rsi
addsd %xmm0, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0xc2c4(%rip), %xmm1     # 0x12158
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq 0x60(%rsi), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7a90
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movl $0x2, %ecx
callq 0x7e40
jmp 0x5ed4
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x6000
movq -0xa8(%rbp), %rdi
callq 0x3430
movb $0x0, -0x65(%rbp)
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0xa0(%rbp)
leaq -0x66(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3120
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x80d0
jmp 0x5f32
leaq -0x66(%rbp), %rdi
callq 0x31c0
movq $0x1, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x5fb8
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8140
movq -0x90(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x70(%rbp), %rsi
shrq %rsi
callq 0x8140
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x70(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x70(%rbp)
jmp 0x5f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x66(%rbp), %rdi
callq 0x31c0
jmp 0x5fe7
movb $0x1, -0x65(%rbp)
testb $0x1, -0x65(%rbp)
jne 0x5fce
movq -0x90(%rbp), %rdi
callq 0x3430
leaq -0x40(%rbp), %rdi
callq 0x3430
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3430
movq -0x60(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>> Vector::operator+<double>(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator+(std::vector<T> vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator+");
    }
    // This is actually implemented as vector1 += vector2, so the first
    // parameter is passed by copy and then overwritten with the result
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::plus<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x619b
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0xc170(%rip), %rsi      # 0x122d6
callq 0x2380
jmp 0x616d
movq -0x80(%rbp), %rdi
movq 0x13e68(%rip), %rsi     # 0x19fe0
movq 0x13e41(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x6202
movq -0x78(%rbp), %rdi
callq 0x45b0
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4270
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x45b0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xab00
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, -0x58(%rbp)
callq 0x4610
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Upconv(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Upconv(const std::vector<T>& x, const std::vector<T>& f, size_t s) const {
  const size_t lf = f.size();
  std::vector<T> y = Dyadup(x);
  y = Wextend(y, lf / 2);
  y = Conv(y, f, kFullConvolution);
  y.erase(y.begin(), y.begin() + lf - 1);
  y.erase(y.begin() + s, y.end());
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31e0
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x18(%rbp), %rdx
callq 0x8160
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0x30(%rbp), %rcx
shrq %rcx
leaq -0x50(%rbp), %rdi
callq 0x7a90
jmp 0x6293
movq -0xe8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0x6000
movq -0x100(%rbp), %rdi
callq 0x3430
movq -0xe8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x78(%rbp), %rdi
xorl %ecx, %ecx
callq 0x7e40
jmp 0x62ce
movq -0xe8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0x110(%rbp)
callq 0x6000
movq -0x110(%rbp), %rdi
callq 0x3430
movq -0xe8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x82e0
movq -0xe8(%rbp), %rdi
callq 0x45b0
movq %rax, -0xa8(%rbp)
movq -0x30(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x8320
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
movl $0x1, %esi
callq 0x8360
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x82e0
movq -0xe8(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x8250
movq %rax, -0x108(%rbp)
jmp 0x6389
movq -0xe8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x45b0
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x8320
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x82e0
movq -0xe8(%rbp), %rdi
callq 0x45e0
movq %rax, -0xd8(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x82e0
movq -0xe8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
callq 0x8250
movq %rax, -0x118(%rbp)
jmp 0x641d
movq -0x118(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x645d
jmp 0x6451
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x3430
jmp 0x646d
movq -0xe8(%rbp), %rdi
callq 0x3430
movq -0xf8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Linrec(std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Linrec(const std::vector<T>& a, size_t num_levels) const {
  Decomposition1D<T> c(num_levels);
  const size_t length = a.size();
  for (size_t k = 0; k < num_levels; k++) {
    // Set k-th level detail coefficients to zero
    std::vector<T> dk(length * (1 << (num_levels - k - 1)), static_cast<T>(0));
    c.SetDetcoef(dk, k);
  }
  // Set approx coefficients equal to the given input
  c.SetAppcoef(a);
  // Call Appcoef with length of reconstruction equal to N*2^n
  return Appcoef(c, 0, length * (1 << num_levels));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4ba0
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7635
movq -0x40(%rbp), %rax
movl -0x20(%rbp), %edx
movl -0x48(%rbp), %ecx
notl %ecx
addl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3120
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rcx
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x76b0
jmp 0x75d1
leaq -0x69(%rbp), %rdi
callq 0x31c0
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4ec0
jmp 0x75ed
leaq -0x60(%rbp), %rdi
callq 0x3430
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7569
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x31c0
jmp 0x769a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3430
jmp 0x769a
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x51f0
jmp 0x7644
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdi
movq -0x40(%rbp), %r8
movb -0x20(%rbp), %cl
movl $0x1, %eax
shll %cl, %eax
cltq
imulq %rax, %r8
xorl %eax, %eax
movl %eax, %ecx
leaq -0x38(%rbp), %rdx
callq 0x5cb0
jmp 0x7675
leaq -0x38(%rbp), %rdi
callq 0x4d10
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d10
movq -0x78(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Linrec(Matrix<double> const&, unsigned long) const
Matrix<T> Wavelet<T>::Linrec(const Matrix<T>& a, size_t num_levels) const {
  Decomposition2D<T> c(num_levels);
  const size_t num_rows = a.GetNumRows();
  const size_t num_cols = a.GetNumColumns();
  for (size_t k = 0; k < num_levels; k++) {
    // Set all subbands at k-th level to zero
    Matrix<T> tmp(num_rows * (1 << (num_levels - k - 1)), num_cols * (1 << (num_levels - k - 1)), static_cast<T>(0));
    c.SetDetcoef(tmp, kDiagonalSubband, k);
    c.SetDetcoef(tmp, kVerticalSubband, k);
    c.SetDetcoef(tmp, kHorizontalSubband, k);
  }
  // Set approx coefficients equal to given input
  c.SetAppcoef(a);
  // Call Appcoef with size_rec equal to to M*2^n-by-N*2^n
  const MatrixSize size_rec(num_rows * (1 << num_levels), num_cols * (1 << num_levels));
  return Appcoef(c, 0, size_rec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5270
movq -0x18(%rbp), %rdi
callq 0xca40
movq %rax, -0xa0(%rbp)
jmp 0x7786
movq -0xa0(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xca60
movq %rax, -0xc0(%rbp)
jmp 0x77a3
movq -0xc0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7890
movq -0x40(%rbp), %rsi
movl -0x20(%rbp), %ecx
movl -0x60(%rbp), %eax
notl %eax
addl %ecx, %eax
movb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cltq
imulq %rax, %rsi
movq -0x58(%rbp), %rdx
imulq %rax, %rdx
leaq -0x88(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xc7e0
jmp 0x77fa
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
xorl %edx, %edx
callq 0x5620
jmp 0x7812
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %edx
callq 0x5620
jmp 0x782d
movq -0x60(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x2, %edx
callq 0x5620
jmp 0x7848
leaq -0x88(%rbp), %rdi
callq 0xca20
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x77b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7906
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xca20
jmp 0x7906
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x57e0
jmp 0x789f
movq -0x40(%rbp), %rsi
movb -0x20(%rbp), %cl
movl $0x1, %eax
shll %cl, %eax
cltq
imulq %rax, %rsi
movq -0x58(%rbp), %rdx
imulq %rax, %rdx
leaq -0x98(%rbp), %rdi
callq 0x7920
jmp 0x78c9
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x38(%rbp), %rdx
leaq -0x98(%rbp), %r8
callq 0x6830
jmp 0x78ed
leaq -0x38(%rbp), %rdi
callq 0x53e0
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x53e0
movq -0x48(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition1D<double> const&, unsigned long) const
std::vector<T> Wavelet<T>::Appcoef(const Decomposition1D<T>& decomposition, size_t level) const {
  if (level >= decomposition.NumLevels()) {
    throw std::invalid_argument("Wavelet::Appcoef");
  }
  const size_t length_rec = (level == 0) ? 2 * decomposition.GetDetcoef(0).size() : decomposition.GetDetcoef(level - 1).size();
  return Appcoef(decomposition, level, length_rec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d30
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x7a18
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0xa838(%rip), %rsi      # 0x1221b
callq 0x2380
jmp 0x79ea
movq -0x60(%rbp), %rdi
movq 0x125eb(%rip), %rsi     # 0x19fe0
movq 0x125c4(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x7a85
cmpq $0x0, -0x20(%rbp)
jne 0x7a3d
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4de0
movq %rax, %rdi
callq 0x31e0
shlq %rax
movq %rax, -0x68(%rbp)
jmp 0x7a5a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x4de0
movq %rax, %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x5cb0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nop
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Dyadup(std::vector<double, std::allocator<double>> const&) const
std::vector<T> Wavelet<T>::Dyadup(const std::vector<T>& x) const {
  // Return a vector having double length
  std::vector<T> y;
  y.reserve(2 * x.size());
  // The output vector interleaves the elements of x with zero
  for (size_t k = 0; k < x.size(); k++) {
    y.push_back(x[k]);
    y.push_back(0);
  }
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5970
movq -0x18(%rbp), %rdi
callq 0x31e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x85d0
jmp 0x81a2
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x8220
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8740
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x86d0
jmp 0x81e2
movq -0x48(%rbp), %rdi
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x8760
jmp 0x81f9
jmp 0x81fb
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x81aa
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3430
jmp 0x823d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8233
movq -0x48(%rbp), %rdi
callq 0x3430
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition2D<double> const&, unsigned long) const
Matrix<T> Wavelet<T>::Appcoef(const Decomposition2D<T>& decomposition, size_t level) const {
  if (level >= decomposition.NumLevels()) {
    throw std::invalid_argument("Wavelet::Appcoef2");
  }
  MatrixSize size_rec;
  if(level == 0) {
    // Level zero contains the biggest size of the decomposition, so we set the
    // reconstruction size equal to twice the size at level zero.
    const MatrixSize size_level_0 = decomposition.GetDetcoef(kHorizontalSubband, 0).Size();
    size_rec = MatrixSize(size_level_0.GetNumRows() * 2, size_level_0.GetNumColums() * 2);
  }
  else {
    // If level is not zero, get size of (any) subband at the next highest
    // level. We take here the horizontal subband.
    size_rec = decomposition.GetDetcoef(kHorizontalSubband, level - 1).Size();
  }
  return Appcoef(decomposition, level, size_rec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5400
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jb 0x844d
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0x9e1d(%rip), %rsi      # 0x1222c
callq 0x2380
jmp 0x8416
movq -0x98(%rbp), %rdi
movq 0x11bbc(%rip), %rsi     # 0x19fe0
movq 0x11b95(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x8525
leaq -0x40(%rbp), %rdi
callq 0x8530
cmpq $0x0, -0x20(%rbp)
jne 0x84c3
movq -0x18(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x54c0
movq %rax, %rdi
callq 0xca80
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8540
shlq %rax
movq %rax, -0xa0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8570
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
shlq %rdx
leaq -0x60(%rbp), %rdi
callq 0x7920
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x84f9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movl $0x2, %esi
callq 0x54c0
movq %rax, %rdi
callq 0xca80
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x6830
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Matrix(unsigned long, unsigned long, std::vector<double, std::allocator<double>> const&)
Matrix<T>::Matrix(size_t num_rows, size_t num_cols, const std::vector<T>& data) {
  if (num_rows * num_cols != data.size()) {
    throw std::invalid_argument("Matrix::Matrix");
  }
  num_rows_ = num_rows;
  num_cols_ = num_cols;
  data_ = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5970
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xc9bf
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x59ce(%rip), %rsi      # 0x12348
callq 0x2380
jmp 0xc981
movq -0x50(%rbp), %rdi
movq 0xd654(%rip), %rsi      # 0x19fe0
movq 0xd62d(%rip), %rdx      # 0x19fc0
callq 0x2330
jmp 0xc9f9
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0xc9e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xc9e7
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rsi
addq $0x10, %rdi
callq 0x4fa0
jmp 0xc9e1
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3430
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Size() const
MatrixSize Matrix<T>::Size() const {
  if (num_rows_ * num_cols_ != data_.size()) {
    throw std::logic_error("Matrix::Size");
  }
  // clang++ suggests braces around initialization of subobject
  return MatrixSize(num_rows_, num_cols_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
imulq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xcb05
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x5887(%rip), %rsi      # 0x12357
callq 0x22a0
jmp 0xcad7
movq -0x40(%rbp), %rdi
movq 0xd4f6(%rip), %rsi      # 0x19fd8
movq 0xd4b7(%rip), %rdx      # 0x19fa0
callq 0x2330
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0xcb27
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x10(%rbp), %rdi
callq 0x7920
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::SetRow(std::vector<double, std::allocator<double>> const&, unsigned long)
void Matrix<T>::SetRow(const std::vector<T>& row, size_t i) {
  if (i >= num_rows_ || num_cols_ != row.size()) {
    throw std::invalid_argument("Matrix::SetRow");
  }
  for (size_t j = 0; j < num_cols_; j++) {
    operator()(i, j) = row.at(j);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jae 0xcfc6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xd016
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x53d6(%rip), %rsi      # 0x123b7
callq 0x2380
jmp 0xcfe8
movq -0x48(%rbp), %rdi
movq 0xcfed(%rip), %rsi      # 0x19fe0
movq 0xcfc6(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0xd070
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd06a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xcf40
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xcd60
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xd01e
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::SetColumn(std::vector<double, std::allocator<double>> const&, unsigned long)
void Matrix<T>::SetColumn(const std::vector<T>& column, size_t j) {
  if (j >= num_cols_ || num_rows_ != column.size()) {
    throw std::invalid_argument("Matrix::SetColumn");
  }
  const ptrdiff_t idx = static_cast<ptrdiff_t>(Subscripts2Index(0, j));
  std::copy(column.begin(), column.end(), data_.begin() + idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd0c6
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0xd116
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x52e5(%rip), %rsi      # 0x123c6
callq 0x2380
jmp 0xd0e8
movq -0x70(%rbp), %rdi
movq 0xceed(%rip), %rsi      # 0x19fe0
movq 0xcec6(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0xd182
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xccb0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42a0
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x45b0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8320
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x9870
movq %rax, -0x58(%rbp)
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::GetRow(unsigned long) const
std::vector<T> Matrix<T>::GetRow(size_t i) const {
  std::vector<T> row;
  row.reserve(num_cols_);
  for (size_t j = 0; j < num_cols_; j++) {
    const T& value = operator()(i, j);
    row.push_back(value);
  }
  return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5970
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x85d0
jmp 0xd283
movq $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd2ee
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xce50
movq %rax, -0x60(%rbp)
jmp 0xd2b0
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x86d0
jmp 0xd2c7
jmp 0xd2c9
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xd28b
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3430
jmp 0xd30b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xd301
movq -0x48(%rbp), %rdi
callq 0x3430
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::DeleteRow(unsigned long)
void Matrix<T>::DeleteRow(size_t i) {
  for (size_t j = 0; j < num_cols_; j++) {
    const ptrdiff_t idx = static_cast<ptrdiff_t>(Subscripts2Index(i, num_cols_ - j - 1));
    data_.erase(data_.begin() + idx);
  }
  num_rows_--;
  assert(Numel() == data_.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd5b7
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x8(%rdi), %rdx
subq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0xccb0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x45b0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8320
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82e0
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd610
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd530
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
addq $-0x1, %rax
movq %rax, (%rdi)
callq 0xcb30
movq -0x48(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x10, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0xd5e9
jmp 0xd608
leaq 0x4df8(%rip), %rdi      # 0x123e8
leaq 0x4e09(%rip), %rsi      # 0x12400
movl $0xb8, %edx
leaq 0x4e08(%rip), %rcx      # 0x1240b
callq 0x2140
addq $0x60, %rsp
popq %rbp
retq
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::DeleteColumn(unsigned long)
void Matrix<T>::DeleteColumn(size_t j) {
  const ptrdiff_t idx_start = static_cast<ptrdiff_t>(Subscripts2Index(0, j));
  const ptrdiff_t idx_end = static_cast<ptrdiff_t>(Subscripts2Index(0, j + 1));
  data_.erase(data_.begin() + idx_start, data_.begin() + idx_end);
  num_cols_--;
  assert(Numel() == data_.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xccb0
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xccb0
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x70(%rbp)
addq $0x10, %rdi
callq 0x45b0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8320
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82e0
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
callq 0x45b0
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8320
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x82e0
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x8250
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq 0x8(%rdi), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rdi)
callq 0xcb30
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x10, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jne 0xd774
jmp 0xd793
leaq 0x4c6d(%rip), %rdi      # 0x123e8
leaq 0x4c7e(%rip), %rsi      # 0x12400
movl $0xc1, %edx
leaq 0x4cb1(%rip), %rcx      # 0x1243f
callq 0x2140
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Diag() const
std::vector<T> Matrix<T>::Diag() const {
  std::vector<T> diag;
  const size_t diag_length = std::min(num_rows_, num_cols_);
  diag.reserve(diag_length);
  for (size_t k = 0; k < diag_length; k++) {
    const T& value = operator()(k, k);
    diag.push_back(value);
  }
  return diag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5970
movq -0x50(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x3dd0
movq %rax, -0x48(%rbp)
jmp 0xd7e2
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x85d0
jmp 0xd7fc
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xd862
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rdx, %rsi
callq 0xce50
movq %rax, -0x68(%rbp)
jmp 0xd824
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x86d0
jmp 0xd83b
jmp 0xd83d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xd804
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3430
jmp 0xd87f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd875
movq -0x60(%rbp), %rdi
callq 0x3430
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Rand(unsigned int)
void Matrix<T>::Rand(unsigned int seed) {
  std::mt19937 gen;
  gen.seed(seed);
  std::uniform_real_distribution<T> dis(0, 1);
  std::generate(data_.begin(), data_.end(), [&dis, &gen]() {
    return dis(gen);
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x13d0, %rsp           # imm = 0x13D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x13d0(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0xd9f0
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x1398(%rbp), %rdi
callq 0xda10
leaq -0x13a8(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x46a4(%rip), %xmm1     # 0x12010
callq 0xdad0
movq -0x13d0(%rbp), %rdi
addq $0x10, %rdi
callq 0x45b0
movq -0x13d0(%rbp), %rdi
movq %rax, -0x13b0(%rbp)
addq $0x10, %rdi
callq 0x45e0
movq %rax, -0x13b8(%rbp)
leaq -0x13a8(%rbp), %rax
movq %rax, -0x13c8(%rbp)
leaq -0x1398(%rbp), %rax
movq %rax, -0x13c0(%rbp)
movq -0x13b0(%rbp), %rdi
movq -0x13b8(%rbp), %rsi
movq -0x13c8(%rbp), %rdx
movq -0x13c0(%rbp), %rcx
callq 0xdb00
addq $0x13d0, %rsp           # imm = 0x13D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Identity()
void Matrix<T>::Identity() {
  if (num_rows_ != num_cols_) {
    throw std::logic_error("Matrix::Identity");
  }
  for (size_t j = 0; j < num_cols_; j++) {
    for (size_t i = 0; i < num_rows_; i++) {
      operator()(i, j) = (i == j)? static_cast<T>(1) : static_cast<T>(0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0xdd60
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x474e(%rip), %rsi      # 0x12476
callq 0x22a0
jmp 0xdd2f
movq -0x38(%rbp), %rdi
movq 0xc29e(%rip), %rsi      # 0x19fd8
movq 0xc25f(%rip), %rdx      # 0x19fa0
callq 0x2330
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2170
jmp 0xde06
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xde00
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
jae 0xdded
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd 0x4271(%rip), %xmm0     # 0x12010
xorps %xmm1, %xmm1
movsd %xmm1, -0x48(%rbp)
cmpq %rcx, %rax
movsd %xmm0, -0x40(%rbp)
je 0xddbb
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xcd60
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdd82
jmp 0xddef
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdd68
addq $0x50, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2350
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Transpose()
void Matrix<T>::Transpose() {
  // TODO: inplace tranposition
  std::vector<T> transposed_data;
  transposed_data.reserve(num_rows_ * num_cols_);
  for (size_t i = 0; i < num_rows_; i++) {
    for (size_t j = 0; j < num_cols_; j++) {
      const T& value = operator()(i, j);
      transposed_data.push_back(value);
    }
  }
  data_ = transposed_data;
  std::swap(num_rows_, num_cols_);
  assert(Numel() == data_.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5970
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rax
imulq %rax, %rsi
callq 0x85d0
jmp 0xde4b
movq $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
jae 0xdee5
movq $0x0, -0x40(%rbp)
movq -0x58(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xded2
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xcd60
movq %rax, -0x60(%rbp)
jmp 0xde91
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x86d0
jmp 0xdea8
jmp 0xdeaa
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xde6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3430
jmp 0xdf60
jmp 0xded4
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xde53
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x4fa0
jmp 0xdef8
movq -0x58(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0xdf70
movq -0x58(%rbp), %rdi
callq 0xcb30
movq %rax, -0x68(%rbp)
jmp 0xdf17
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jne 0xdf32
jmp 0xdf51
leaq 0x44af(%rip), %rdi      # 0x123e8
leaq 0x44c0(%rip), %rsi      # 0x12400
movl $0x101, %edx            # imm = 0x101
leaq 0x453b(%rip), %rcx      # 0x12487
callq 0x2140
leaq -0x20(%rbp), %rdi
callq 0x3430
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Reshape(unsigned long, unsigned long)
void Matrix<T>::Reshape(size_t num_rows, size_t num_cols) {
  if (num_rows * num_cols != Numel()) {
    throw std::invalid_argument("Matrix::Reshape");
  }
  num_rows_ = num_rows;
  num_cols_ = num_cols;
  assert(Numel() == data_.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xcb30
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xe03a
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x44b0(%rip), %rsi      # 0x124b5
callq 0x2380
jmp 0xe00c
movq -0x40(%rbp), %rdi
movq 0xbfc9(%rip), %rsi      # 0x19fe0
movq 0xbfa2(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0xe096
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0xcb30
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0xe071
jmp 0xe090
leaq 0x4370(%rip), %rdi      # 0x123e8
leaq 0x4381(%rip), %rsi      # 0x12400
movl $0x10b, %edx            # imm = 0x10B
leaq 0x443a(%rip), %rcx      # 0x124c5
callq 0x2140
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nop
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::operator*(Matrix<double> const&) const
Matrix<T> Matrix<T>::operator*(const Matrix<T>& rhs) const {
  if (rhs.GetNumRows() != num_cols_) {
    throw std::invalid_argument("Matrix::operator*");
  }
  Matrix<T> res(num_rows_, rhs.GetNumColumns(), 0.0);
  for(size_t i = 0; i < num_rows_; i++) {
    for(size_t j = 0; j < rhs.GetNumColumns(); j++) {
      T& value = res(i, j);
      for(size_t k = 0; k < num_cols_; k++) {
        value += operator()(i, k) * rhs(k, j);
      }
    }
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xca40
movq -0x50(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xe410
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x4127(%rip), %rsi      # 0x124ff
callq 0x2380
jmp 0xe3df
movq -0x68(%rbp), %rdi
movq 0xbbf6(%rip), %rsi      # 0x19fe0
movq 0xbbcf(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0xe592
movq -0x50(%rbp), %rax
movb $0x0, -0x25(%rbp)
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0xca60
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
xorps %xmm0, %xmm0
callq 0xc7e0
movq $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jae 0xe572
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0xca60
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xe55f
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xcd60
movq %rax, -0x80(%rbp)
jmp 0xe494
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xe54c
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xce50
movq %rax, -0x88(%rbp)
jmp 0xe4d0
movq -0x88(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xce50
movq %rax, -0x90(%rbp)
jmp 0xe4fd
movsd -0x98(%rbp), %xmm0
movq -0x90(%rbp), %rax
movsd (%rax), %xmm2
movq -0x40(%rbp), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xe4a4
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xca20
jmp 0xe592
jmp 0xe54e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xe45c
jmp 0xe561
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe443
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0xe585
movq -0x60(%rbp), %rdi
callq 0xca20
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::operator+(Matrix<double>) const
Matrix<T> Matrix<T>::operator+(Matrix<T> rhs) const {
  if (Size() != rhs.Size()) {
    throw std::invalid_argument("Matrix::operator+");
  }
  rhs.GetData() += data_;
  return rhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xca80
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
callq 0xca80
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe6a0
testb $0x1, %al
jne 0xe5ff
jmp 0xe64f
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x3ef7(%rip), %rsi      # 0x12511
callq 0x2380
jmp 0xe621
movq -0x70(%rbp), %rdi
movq 0xb9b4(%rip), %rsi      # 0x19fe0
movq 0xb98d(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2170
jmp 0xe68a
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
callq 0xd4d0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0xe6d0
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3490
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>>& Vector::operator+=<double>(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&)
std::vector<T>& operator+=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator+=");
    }
    // The first parameter is passed by reference, modified and returned
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::plus<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xe752
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x3e66(%rip), %rsi      # 0x12583
callq 0x2380
jmp 0xe724
movq -0x60(%rbp), %rdi
movq 0xb8b1(%rip), %rsi      # 0x19fe0
movq 0xb88a(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0xe7a9
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xab00
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>>& Vector::operator-=<double>(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&)
std::vector<T>& operator-=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    if(vector1.size()!=vector2.size()) {
      throw std::invalid_argument("std::vector operator-=");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::minus<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xe942
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x3c8d(%rip), %rsi      # 0x1259a
callq 0x2380
jmp 0xe914
movq -0x60(%rbp), %rdi
movq 0xb6c1(%rip), %rsi      # 0x19fe0
movq 0xb69a(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0xe999
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x4510
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::ElementProduct(Matrix<double>) const
Matrix<T> Matrix<T>::ElementProduct(Matrix<T> rhs) const {
  if (Size() != rhs.Size()) {
    throw std::invalid_argument("Matrix::ElementProduct");
  }
  rhs.GetData() *= data_;
  return rhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xca80
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
callq 0xca80
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe6a0
testb $0x1, %al
jne 0xea0f
jmp 0xea5f
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x3b0b(%rip), %rsi      # 0x12535
callq 0x2380
jmp 0xea31
movq -0x70(%rbp), %rdi
movq 0xb5a4(%rip), %rsi      # 0x19fe0
movq 0xb57d(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2170
jmp 0xea9a
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
callq 0xd4d0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0xeab0
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3490
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)