LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Decomposition2D<double>::SetDetcoef(Matrix<double> const&, WaveledSubbdand, unsigned long)
void Decomposition2D<T>::SetDetcoef(const Matrix<T>& d, WaveledSubbdand subband, size_t n) {
  if (subband != kHorizontalSubband && subband != kVerticalSubband && subband != kDiagonalSubband) {
    throw std::invalid_argument("Decomposition2D::SetDetcoef");
  }
  if (n >= NumLevels()) {
    throw std::invalid_argument("Decomposition2D::SetDetcoef ");
  }
  const size_t idx = static_cast<size_t>(subband);
  this->at(3 * n + idx) = d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jae 0x33d9
movl %edx, %r8d
movq %rsi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
decq %rax
pushq $0x3
popq %rsi
xorl %edx, %edx
divq %rsi
cmpq %rcx, %rax
jbe 0x33f5
movl %r8d, %eax
leaq (%rcx,%rcx,2), %rsi
addq %rax, %rsi
callq 0x343a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3458
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4df6(%rip), %rsi      # 0x81e1
movq %rax, %rdi
callq 0x22e0
jmp 0x340f
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4df6(%rip), %rsi      # 0x81fd
movq %rax, %rdi
callq 0x22e0
movq 0x9bca(%rip), %rsi      # 0xcfe0
movq 0x9ba3(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
jmp 0x3427
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wavelet(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
Wavelet<T>::Wavelet(const std::vector<T>& Lo_D, const std::vector<T>& Hi_D,
                    const std::vector<T>& Lo_R, const std::vector<T>& Hi_R) {
  Lo_D_ = Lo_D;
  Hi_D_ = Hi_D;
  Lo_R_ = Lo_R;
  Hi_R_ = Hi_R;
  half_length_filter_ = Lo_D_.size() / 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
leaq 0x30(%rdi), %r15
leaq 0x48(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x3132
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x3132
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3132
movq %r12, %rdi
movq %r13, %rsi
callq 0x3132
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
shrq %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x2d52
movq %r15, %rdi
callq 0x2d52
movq (%rsp), %rdi
callq 0x2d52
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wavedec(std::vector<double, std::allocator<double>> const&, unsigned long) const
Decomposition1D<T> Wavelet<T>::Wavedec(const std::vector<T>& x, size_t num_levels) const {
  if (x.size() < (1 << num_levels)) {
    throw std::invalid_argument("Wavelet::Wavedec");
  }
  Decomposition1D<T> decomposition(num_levels);
  std::vector<T> a = x;
  for (size_t k = 0; k < num_levels; k++) {
    std::vector<T> ak, dk;
    Dwt(a, ak, dk);
    // Save approximation coefficients for next iteration
    a = ak;
    // Store detail coefficients of current level k to Decomposition object
    decomposition.SetDetcoef(dk, k);
  }
  // Store final approximation coefficients
  decomposition.SetAppcoef(a);
  return decomposition;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
pushq $0x1
popq %rdx
shll %cl, %edx
sarq $0x3, %rax
movslq %edx, %rcx
cmpq %rcx, %rax
jb 0x3649
movq %rsi, %r15
movq %rdi, (%rsp)
movq %r14, %rsi
callq 0x2f7c
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2b30
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
leaq 0x40(%rsp), %rbp
leaq 0x20(%rsp), %rbx
cmpq %r12, %r14
je 0x361c
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x36c2
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3132
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x30b6
movq %rbx, %rdi
callq 0x2d52
movq %rbp, %rdi
callq 0x2d52
incq %r12
jmp 0x35be
leaq 0x8(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x31fc
leaq 0x8(%rsp), %rdi
callq 0x2d52
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x4bbf(%rip), %rsi      # 0x821a
movq %rax, %rdi
callq 0x22e0
movq 0x9976(%rip), %rsi      # 0xcfe0
movq 0x994f(%rip), %rdx      # 0xcfc0
movq %r14, %rdi
callq 0x22a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2140
jmp 0x36ba
movq %rax, %rbx
jmp 0x36a7
movq %rax, %rbx
jmp 0x36b1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2d52
leaq 0x40(%rsp), %rdi
callq 0x2d52
leaq 0x8(%rsp), %rdi
callq 0x2d52
movq (%rsp), %rdi
callq 0x300a
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition1D<double> const&, unsigned long, unsigned long) const
std::vector<T> Wavelet<T>::Appcoef(const Decomposition1D<T>& decomposition, size_t level, size_t length_rec) const {
  std::vector<T> a = decomposition.GetAppcoef();
  for (size_t k = decomposition.NumLevels(); k != level; k--) {
    // Get size from next upper level, if current level is the final then
    // resort to the final lenght argument sz
    const size_t length_rec_k = k != 1 ? decomposition.GetDetcoef(k - 2).size() : length_rec;
    // Reconstruct signal of size s from kth level approx and detail
    a = Idwt(a, decomposition.GetDetcoef(k - 1), length_rec_k);
  }
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
addq $-0x18, %rsi
callq 0x2b30
movq 0x8(%r12), %rax
subq (%r12), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %rbp
addq $-0x3, %rbp
negq %r15
leaq 0x10(%rsp), %r14
leaq (%r15,%rbp), %rax
cmpq $-0x2, %rax
je 0x3803
movq 0x8(%rsp), %r13
cmpq $-0x1, %rbp
je 0x37ca
movq %r12, %rdi
movq %rbp, %rsi
callq 0x302e
movq 0x8(%rax), %r13
subq (%rax), %r13
sarq $0x3, %r13
leaq 0x1(%rbp), %rsi
movq %r12, %rdi
callq 0x302e
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
movq %rax, %rcx
movq %r13, %r8
callq 0x3956
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5482
movq %r14, %rdi
callq 0x2d52
decq %rbp
jmp 0x379f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3817
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x3, %rax
movq %rax, %xmm1
punpckldq 0x48e8(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rdi, %rbx
subpd 0x48ed(%rip), %xmm1     # 0x8150
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x48e9(%rip), %xmm0     # 0x8160
callq 0x2050
movapd %xmm0, 0x20(%rsp)
movq 0x60(%r12), %rcx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x48e8
leaq 0x38(%rsp), %rdi
pushq $0x2
popq %rcx
movq %r13, %rsi
movq %r14, %rdx
callq 0x49ea
movapd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x489d(%rip), %xmm0     # 0x8168
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r14
movq %r14, %rsi
callq 0x5482
movq %r14, %rdi
callq 0x2d52
movq %r15, %rsi
shrq %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x4b9c
movq 0x8(%rsp), %rax
movq (%rbx), %rcx
pushq $0x1
popq %rdx
cmpq %r15, %rdx
ja 0x3924
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x4(%rcx,%rdx,4)
addq $0x2, %rdx
jmp 0x390e
leaq 0x8(%rsp), %rdi
callq 0x2d52
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3941
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d52
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
movq (%rdx), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq %rax, %rdi
jne 0x3a43
movq %rcx, %rdi
callq 0x54d3
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x485d(%rip), %rsi      # 0x82b2
movq %rax, %rdi
callq 0x22e0
movq 0x957c(%rip), %rsi      # 0xcfe0
movq 0x9555(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rcx), %rbp
subq (%rcx), %rbp
movq %rbp, %r13
sarq $0x3, %r13
callq 0x4bee
shrq %r13
movq %rsp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x48e8
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5482
movq %r12, %rdi
callq 0x2d52
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x49ea
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5482
movq %r15, %rdi
callq 0x2d52
movq (%rbx), %rsi
leaq (%rsi,%rbp), %rdx
addq $-0x8, %rdx
movq %rbx, %rdi
callq 0x4c88
shlq $0x3, %r14
addq (%rbx), %r14
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c88
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b44
jmp 0x3b44
jmp 0x3b44
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wavedec(Matrix<double> const&, unsigned long) const
Decomposition2D<T> Wavelet<T>::Wavedec(const Matrix<T>& x, size_t num_levels) const {
  if (x.GetNumRows() < (1 << num_levels) || x.GetNumColumns() < (1 << num_levels)) {
    throw std::invalid_argument("Wavelet::Wavedec");
  }
  Decomposition2D<T> decomposition(num_levels);
  Matrix<T> a = x;
  for (size_t k = 0; k < num_levels; k++) {
    Matrix<T> ak, hk, vk, dk;
    Dwt(a, ak, hk, vk, dk);
    // Save approximation coefficients for next iteration
    a = ak;
    // Store subbands obtained at current level k to Decomposition object
    decomposition.SetDetcoef(dk, kDiagonalSubband, k);
    decomposition.SetDetcoef(vk, kVerticalSubband, k);
    decomposition.SetDetcoef(hk, kHorizontalSubband, k);
  }
  // Store final approximation
  decomposition.SetAppcoef(a);
  return decomposition;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x5a94
pushq $0x1
popq %rdx
movq %r15, (%rsp)
movl %r15d, %ecx
shll %cl, %edx
movslq %edx, %r15
cmpq %r15, %rax
jb 0x3cb6
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jb 0x3cb6
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x320a
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2b7e
xorl %r12d, %r12d
leaq 0xb0(%rsp), %r13
leaq 0x88(%rsp), %rbp
leaq 0x60(%rsp), %r15
leaq 0x38(%rsp), %r14
cmpq %r12, (%rsp)
je 0x3c8a
movq %r13, %rdi
callq 0x5a7c
movq %rbp, %rdi
callq 0x5a7c
movq %r15, %rdi
callq 0x5a7c
movq %r14, %rdi
callq 0x5a7c
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x3d5a
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x3458
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x338a
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0x338a
movq %rbx, %rdi
movq %rbp, %rsi
pushq $0x2
popq %rdx
movq %r12, %rcx
callq 0x338a
movq %r14, %rdi
callq 0x5a8a
movq %r15, %rdi
callq 0x5a8a
movq %rbp, %rdi
callq 0x5a8a
movq %r13, %rdi
callq 0x5a8a
incq %r12
jmp 0x3bde
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3474
leaq 0x10(%rsp), %rdi
callq 0x5a8a
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4552(%rip), %rsi      # 0x821a
movq %rax, %rdi
callq 0x22e0
movq 0x9309(%rip), %rsi      # 0xcfe0
movq 0x92e2(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
jmp 0x3cfa
movq %rax, %r14
jmp 0x3d49
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
jmp 0x3d51
movq %rax, %r14
jmp 0x3d3f
movq %rax, %r14
jmp 0x3d32
movq %rax, %r14
jmp 0x3d25
movq %rax, %r14
jmp 0x3d1b
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5a8a
leaq 0x60(%rsp), %rdi
callq 0x5a8a
leaq 0x88(%rsp), %rdi
callq 0x5a8a
leaq 0xb0(%rsp), %rdi
callq 0x5a8a
leaq 0x10(%rsp), %rdi
callq 0x5a8a
movq %rbx, %rdi
callq 0x329c
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition2D<double> const&, unsigned long, MatrixSize const&) const
Matrix<T> Wavelet<T>::Appcoef(const Decomposition2D<T>& decomposition, size_t level,
                              const MatrixSize& size_rec) const {
  Matrix<T> a = decomposition.GetAppcoef();
  for (size_t k = decomposition.NumLevels(); k != level; k--) {
    // Select size of reconstruction from any subband at the next highest level
    // We arbitrarily use the horizontal subband. If there is no next highest
    // level, then we use the size_rec argument.
    const MatrixSize s = (k != 1) ? decomposition.GetDetcoef(kHorizontalSubband, k - 2).Size() : size_rec;
    const Matrix<T>& hk = decomposition.GetDetcoef(kHorizontalSubband, k - 1);
    const Matrix<T>& vk = decomposition.GetDetcoef(kVerticalSubband, k - 1);
    const Matrix<T>& dk = decomposition.GetDetcoef(kDiagonalSubband, k - 1);
    a = Idwt(a, hk, vk, dk, s);
  }
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
addq $-0x28, %rsi
callq 0x2b7e
movq 0x8(%r12), %rax
subq (%r12), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
decq %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rbp
decq %rbp
negq %r14
movq %r14, 0x38(%rsp)
leaq 0x40(%rsp), %r14
movq 0x38(%rsp), %rax
addq %rbp, %rax
cmpq $-0x1, %rax
je 0x3ec2
testq %rbp, %rbp
je 0x3e49
leaq -0x1(%rbp), %rdx
movq %r12, %rdi
pushq $0x2
popq %rsi
callq 0x32c8
movq %rax, %rdi
callq 0x5a9e
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
jmp 0x3e56
movq 0x28(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
pushq $0x2
popq %rsi
movq %rbp, %rdx
callq 0x32c8
movq %rax, %r13
movq %r12, %rdi
pushq $0x1
popq %rsi
movq %rbp, %rdx
callq 0x32c8
movq %rax, %r15
movq %r12, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x32c8
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
movq 0x30(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rax, %r9
callq 0x41e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3458
movq %r14, %rdi
callq 0x5a8a
decq %rbp
jmp 0x3e0f
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3eeb
jmp 0x3eeb
jmp 0x3eeb
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5a8a
jmp 0x3eee
jmp 0x3eeb
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a8a
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Upconv(Matrix<double> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, MatrixSize const&) const
Matrix<T> Wavelet<T>::Upconv(const Matrix<T>& x, const std::vector<T>& f1, const std::vector<T>& f2, const MatrixSize& s) const {
  // Upsample each column
  Matrix<T> tmp(s[0], x.GetNumColumns());
  for (size_t j = 0; j < x.GetNumColumns(); j++) {
    tmp.SetColumn(Upconv(x.GetColumn(j), f1, s.GetNumRows()), j);
  }
  // Upsample each row of tmp Matrix
  Matrix<T> y(s.GetNumRows(), s.GetNumColums());
  for (size_t i = 0; i < y.GetNumRows(); i++) {
    y.SetRow(Upconv(tmp.GetRow(i), f2, s.GetNumColums()), i);
  }
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq (%r9), %rbx
movq %rdx, %rdi
callq 0x5a98
leaq 0x50(%rsp), %rdi
xorps %xmm0, %xmm0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x5968
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
leaq 0x38(%rsp), %r13
movq %rbp, %rdi
callq 0x5a98
cmpq %rax, %r15
jae 0x443b
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x5fa6
movq (%r14), %r8
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq 0x18(%rsp), %rcx
callq 0x3a86
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5e26
movq %r13, %rdi
callq 0x2d52
movq %rbx, %rdi
callq 0x2d52
incq %r15
jmp 0x43e5
movq (%r14), %rsi
movq 0x8(%r14), %rdx
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rdi
callq 0x5968
xorl %r15d, %r15d
leaq 0x20(%rsp), %r13
leaq 0x50(%rsp), %rbp
leaq 0x38(%rsp), %rbx
movq 0x8(%rsp), %rdi
callq 0x5a94
cmpq %rax, %r15
jae 0x44ba
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x5f36
movq 0x8(%r14), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
callq 0x3a86
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5d70
movq %rbx, %rdi
callq 0x2d52
movq %r13, %rdi
callq 0x2d52
incq %r15
jmp 0x4461
leaq 0x50(%rsp), %rdi
callq 0x5a8a
movq 0x8(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4529
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x2d52
jmp 0x44ec
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2d52
jmp 0x451d
jmp 0x451a
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x2d52
jmp 0x450c
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2d52
jmp 0x452c
jmp 0x4529
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x5a8a
jmp 0x452c
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x5a8a
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
movq %rcx, %rsi
callq 0x2f7c
movq 0x8(%r14), %r15
movq %r14, 0x20(%rsp)
subq (%r14), %r15
sarq $0x3, %r15
movq %rbx, %rbp
negq %rbp
movq %rbx, 0x10(%rsp)
leal -0x1(%rbx), %r14d
xorl %ebx, %ebx
pushq $0x1
popq %r12
leaq 0x50(%rsp), %r13
movq %rbp, %rax
addq %rbx, %rax
je 0x45e2
movl %r12d, %eax
movl %r14d, %ecx
shll %cl, %eax
movslq %eax, %rsi
imulq %r15, %rsi
andq $0x0, 0x30(%rsp)
movq %r13, %rdi
leaq 0x30(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x4662
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x30b6
movq %r13, %rdi
callq 0x2d52
incq %rbx
decl %r14d
jmp 0x4593
movq 0x40(%rsp), %rdi
addq $-0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x3132
movq 0x28(%rsp), %rbx
movq 0x10(%rsp), %rcx
shll %cl, %r12d
movslq %r12d, %rax
imulq %rax, %r15
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x3752
leaq 0x38(%rsp), %rdi
callq 0x300a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x463e
movq %rax, %rbx
jmp 0x4650
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2d52
leaq 0x38(%rsp), %rdi
callq 0x300a
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
movq %rcx, %rsi
callq 0x320a
movq %r12, %rdi
callq 0x5a94
movq %rax, 0x10(%rsp)
movq %r14, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %r12, %rdi
callq 0x5a98
movq %rax, 0x8(%rsp)
movq %r15, %rbp
negq %rbp
movq %r15, 0x18(%rsp)
leal -0x1(%r15), %ebx
xorl %r13d, %r13d
pushq $0x1
popq %r14
leaq 0x50(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %rbp, %rax
addq %r13, %rax
je 0x4795
movl %r14d, %eax
movl %ebx, %ecx
shll %cl, %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rsi
imulq %rdx, %rsi
imulq 0x8(%rsp), %rdx
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x5968
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x338a
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %r13, %rcx
callq 0x338a
movq %r12, %rdi
movq %r15, %rsi
pushq $0x2
popq %rdx
movq %r13, %rcx
callq 0x338a
movq %r15, %rdi
callq 0x5a8a
incq %r13
decl %ebx
jmp 0x4728
movq 0x40(%rsp), %rdi
addq $-0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x3458
movq 0x18(%rsp), %rcx
shll %cl, %r14d
movslq %r14d, %rax
movq 0x10(%rsp), %rcx
imulq %rax, %rcx
movq 0x8(%rsp), %rdx
imulq %rax, %rdx
leaq 0x50(%rsp), %r8
movq %rcx, (%r8)
movq %rdx, 0x8(%r8)
leaq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x3db2
leaq 0x38(%rsp), %rdi
callq 0x329c
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x480c
jmp 0x480c
jmp 0x480c
movq %rax, %rbx
jmp 0x481e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5a8a
leaq 0x38(%rsp), %rdi
callq 0x329c
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8(%rdx), %rax
subq (%rdx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
decq %rax
cmpq %rbx, %rax
jbe 0x48a4
movq %rsi, %r12
movq %rdi, %r15
testq %rbx, %rbx
sete %bpl
xorl %esi, %esi
movq %rbx, %rax
subq $0x1, %rax
cmovaeq %rax, %rsi
movq %r14, %rdi
callq 0x302e
movq 0x8(%rax), %r8
subq (%rax), %r8
xorb $0x3, %bpl
movl %ebp, %ecx
sarq %cl, %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3752
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x3975(%rip), %rsi      # 0x822b
movq %rax, %rdi
callq 0x22e0
movq 0x871b(%rip), %rsi      # 0xcfe0
movq 0x86f4(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wextend(std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Wextend(const std::vector<T>& x, size_t lenEXT) const {
  std::vector<T> temp = x;
  // Add extra sample if signal is odd
  if (x.size() % 2 == 1) {
    temp.push_back(temp.back());
  }
  // Handle cases when x is shorter than lenEXT
  const size_t rep = lenEXT / temp.size(); // (size_t)std::floor(lenEXT/temp.size());
  const size_t len = lenEXT % temp.size();
  std::vector<T> y;
  y.reserve(2 * (len + rep * temp.size()) + temp.size());
  // Copy last len elements at the beginning
  y.insert(y.begin(), temp.end() - len, temp.end());
  for (size_t k = 0; k < 2 * rep + 1; k++) {
    y.insert(y.end(), temp.begin(), temp.end());
  }
  // Copy first len elements at the end
  y.insert(y.end(), temp.begin(), temp.begin() + len);
  return y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2b30
movl 0x8(%r15), %eax
subl (%r15), %eax
testb $0x8, %al
je 0x4922
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
addq $-0x8, %rsi
callq 0x4e02
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
sarq $0x3, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq %rdx, %r14
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rcx, %rax
imulq %r15, %rax
addq %rdx, %rax
leaq (%rcx,%rax,2), %rsi
movq %rbx, %rdi
callq 0x4d6c
movq (%rbx), %rsi
movq 0x8(%rsp), %rcx
leaq (,%r14,8), %rax
movq %rcx, %rdx
subq %rax, %rdx
movq %rbx, %rdi
callq 0x4e24
addq %r15, %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
cmpq %r15, %r12
ja 0x49a1
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x4e24
incq %r12
jmp 0x4982
leaq (%rdx,%r14,8), %rcx
movq %rbx, %rdi
callq 0x4e24
movq %rsp, %rdi
callq 0x2d52
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x49da
jmp 0x49cf
jmp 0x49cf
jmp 0x49cf
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %rsp, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
callq 0x4d6c
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0x4c5f
addq %r12, %rsi
movq %rbx, %rdi
callq 0x4e02
andq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b8
incq %r13
addq $0x8, %r12
jmp 0x4c27
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4c74
jmp 0x4c74
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
decq %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
cmpq %r14, %rax
jbe 0x4d29
movq %rsi, %r12
movq %rdi, %rbx
testq %r14, %r14
je 0x4ce2
leaq -0x1(%r14), %rdx
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x32c8
movq %rax, %rdi
callq 0x5a9e
jmp 0x4cfd
pushq $0x2
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x32c8
movq %rax, %rdi
callq 0x5a9e
addq %rax, %rax
addq %rdx, %rdx
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3db2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x3501(%rip), %rsi      # 0x823c
movq %rax, %rdi
callq 0x22e0
movq 0x8296(%rip), %rsi      # 0xcfe0
movq 0x826f(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %rdx, %rax
imulq %rsi, %rax
movq 0x8(%rcx), %r8
subq (%rcx), %r8
sarq $0x3, %r8
cmpq %r8, %rax
jne 0x5a2c
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x3132
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x2902(%rip), %rsi      # 0x8340
movq %rax, %rdi
callq 0x22e0
movq 0x7593(%rip), %rsi      # 0xcfe0
movq 0x756c(%rip), %rdx      # 0xcfc0
movq %r14, %rdi
callq 0x22a0
movq %rax, %r15
movq %r14, %rdi
callq 0x2140
jmp 0x5a6c
movq %rax, %r15
movq %rbx, %rdi
callq 0x2d52
movq %r15, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rdx, %rcx
imulq %rax, %rcx
movq 0x18(%rdi), %rsi
subq 0x10(%rdi), %rsi
sarq $0x3, %rsi
cmpq %rsi, %rcx
jne 0x5ac9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x2874(%rip), %rsi      # 0x834f
movq %rax, %rdi
callq 0x2200
movq 0x74ee(%rip), %rsi      # 0xcfd8
movq 0x74af(%rip), %rdx      # 0xcfa0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, (%rdi)
jbe 0x5de2
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x5de2
movq %rdx, %rbx
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x5dd6
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d4e
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5c4a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r12
movq 0x8(%r15), %rax
jmp 0x5d9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x25bb(%rip), %rsi      # 0x83af
movq %rax, %rdi
callq 0x22e0
movq 0x71dd(%rip), %rsi      # 0xcfe0
movq 0x71b6(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq %rdx, 0x8(%rdi)
jbe 0x5e7b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
cmpq %rax, (%rdi)
jne 0x5e7b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5be6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
je 0x5e73
shlq $0x3, %rax
addq 0x10(%rbx), %rax
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2260
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x2531(%rip), %rsi      # 0x83be
movq %rax, %rdi
callq 0x22e0
movq 0x7144(%rip), %rsi      # 0xcfe0
movq 0x711d(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x4d6c
xorl %r12d, %r12d
cmpq 0x8(%r15), %r12
jae 0x5f82
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5cca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e02
incq %r12
jmp 0x5f5e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5f93
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
pushq $-0x1
popq %r12
xorl %r13d, %r13d
movq 0x8(%rbx), %rdx
cmpq %rdx, %r13
jae 0x6071
addq %r12, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5be6
leaq (,%rax,8), %rsi
addq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x60b6
incq %r13
decq %r12
jmp 0x603e
decq (%rbx)
movq %rbx, %rdi
callq 0x5b0c
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6097
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2342(%rip), %rdi      # 0x83e0
leaq 0x2353(%rip), %rsi      # 0x83f8
leaq 0x2357(%rip), %rcx      # 0x8403
movl $0xb8, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
movq %r14, %rdx
callq 0x5be6
movq %rax, %r15
incq %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5be6
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq (%rcx,%r15,8), %rsi
leaq (%rcx,%rax,8), %rdx
callq 0x4c88
decq 0x8(%rbx)
movq %rbx, %rdi
callq 0x5b0c
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6150
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2289(%rip), %rdi      # 0x83e0
leaq 0x229a(%rip), %rsi      # 0x83f8
leaq 0x22d2(%rip), %rcx      # 0x8437
movl $0xc1, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq %r15, %rsi
callq 0x4d6c
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x61c5
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x5cca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e02
incq %r12
jmp 0x61a2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x61d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d52
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x13a0, %rsp           # imm = 0x13A0
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x6258
movl %ebx, %esi
movq %r15, %rdi
callq 0x6262
xorps %xmm0, %xmm0
movhps 0x20dc(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq %r15, %rcx
callq 0x6299
addq $0x13a0, %rsp           # imm = 0x13A0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jne 0x63fb
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rax, %rcx
cmpq %rcx, %r14
jae 0x63f1
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x63e8
movsd 0x1f56(%rip), %xmm0     # 0x8310
cmpq %r15, %r14
je 0x63c2
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5c4a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r15
movq (%rbx), %rax
jmp 0x63ad
incq %r14
movq 0x8(%rbx), %rcx
jmp 0x63a5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x2061(%rip), %rsi      # 0x846e
movq %rax, %rdi
callq 0x2200
movq 0x6bbc(%rip), %rsi      # 0xcfd8
movq 0x6b7d(%rip), %rdx      # 0xcfa0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
movdqa %xmm0, (%rdi)
movq 0x8(%rbx), %rsi
imulq (%rbx), %rsi
callq 0x4d6c
xorl %r14d, %r14d
movq %rsp, %r15
cmpq (%rbx), %r14
jae 0x64a0
xorl %r12d, %r12d
cmpq 0x8(%rbx), %r12
jae 0x649b
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5c4a
movq %r15, %rdi
movq %rax, %rsi
callq 0x4e02
incq %r12
jmp 0x6477
incq %r14
jmp 0x646f
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x3132
movdqu (%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x5b0c
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x64e6
movq %rsp, %rdi
callq 0x2d52
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1ef3(%rip), %rdi      # 0x83e0
leaq 0x1f04(%rip), %rsi      # 0x83f8
leaq 0x1f84(%rip), %rcx      # 0x847f
movl $0x101, %edx            # imm = 0x101
callq 0x2120
jmp 0x6507
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2d52
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
imulq %rsi, %r12
callq 0x5b0c
cmpq %rax, %r12
jne 0x6568
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x5b0c
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6598
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x1f33(%rip), %rsi      # 0x84ad
movq %rax, %rdi
callq 0x22e0
movq 0x6a57(%rip), %rsi      # 0xcfe0
movq 0x6a30(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
leaq 0x1e41(%rip), %rdi      # 0x83e0
leaq 0x1e52(%rip), %rsi      # 0x83f8
leaq 0x1f10(%rip), %rcx      # 0x84bd
movl $0x10b, %edx            # imm = 0x10B
callq 0x2120
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a9e
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r14, %rdi
callq 0x5a9e
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r12, %rdi
callq 0x6851
testb %al, %al
jne 0x680e
addq $0x10, %r15
leaq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x685b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b7e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x1ce9(%rip), %rsi      # 0x8509
movq %rax, %rdi
callq 0x22e0
movq 0x67b1(%rip), %rsi      # 0xcfe0
movq 0x678a(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
movq (%rax), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq %rax, %rdi
jne 0x6894
movq %rcx, %rdi
callq 0x54d3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x1cd5(%rip), %rsi      # 0x857b
movq %rax, %rdi
callq 0x22e0
movq 0x672b(%rip), %rsi      # 0xcfe0
movq 0x6704(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
nop