LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/BL2009/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "BL2009_dataset2.kms.rv";

    load(datafile, "kms", 0);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x32400(%rip), %rdx     # 0x53548
leaq 0x323f1(%rip), %r14     # 0x53540
leaq 0x2423b(%rip), %rcx     # 0x45391
movl $0x16, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x1e370(%rip), %rsi     # 0x3f4e8
movq %r14, %rdi
callq 0x2136f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21472
movq %r14, %rdi
movl $0x32, %esi
callq 0x21544
leaq 0x8(%rsp), %rdi
callq 0x21722
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21722
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-trialdivtab.c
// Function: sumspills
int
sumspills (mpz_t ppp, mpz_t *a, int n)
{
  mpz_t s;
  int i, ret;

  mpz_init_set (s, a[0]);

  for (i = 1; i < n; i++)
    {
      mpz_add (s, s, a[i]);
    }
  ret = mpz_cmp (s, B) >= 0;
  mpz_clear (s);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %rbx
leaq -0x30(%rbp), %r15
movq $0x1, (%r15)
movl $0x8, %edi
callq *0x5cec(%rip)           # 0xf0a0
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x249e
cmpl $0x2, %r14d
jl 0x93ee
movl %r14d, %r15d
addq $0x10, %rbx
decq %r15
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30dc
addq $0x10, %rbx
decq %r15
jne 0x93d7
leaq 0x5ceb(%rip), %rsi      # 0xf0e0
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2d1a
movl %eax, %r14d
notl %r14d
shrl $0x1f, %r14d
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq *0x5c99(%rip)           # 0xf0b0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Decomposition2D<double>::GetDetcoef(WaveledSubbdand, unsigned long) const
const Matrix<T>& Decomposition2D<T>::GetDetcoef(WaveledSubbdand subband, size_t n) const {
  if (subband != kHorizontalSubband && subband != kVerticalSubband && subband != kDiagonalSubband) {
    throw std::invalid_argument("Decomposition2D::GetDetcoef");
  }
  if (n >= NumLevels()) {
    throw std::invalid_argument("Decomposition2D::GetDetcoef ");
  }
  // Convert subband to int for indexing
  const size_t idx = static_cast<size_t>(subband);
  return this->at(3 * n + idx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jae 0x37f9
movq %rdx, %r8
movq (%rdi), %r9
movq 0x8(%rdi), %rax
subq %r9, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
leaq -0x1(%rcx), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
cmpq %r8, %rdx
jbe 0x3817
movl %esi, %eax
leaq (%r8,%r8,2), %rsi
addq %rax, %rsi
cmpq %rsi, %rcx
jbe 0x3849
leaq (%rsi,%rsi,4), %rax
leaq (%r9,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x596b(%rip), %rsi      # 0x9178
movq %rax, %rdi
callq 0x22f0
jmp 0x3833
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x5969(%rip), %rsi      # 0x9194
movq %rax, %rdi
callq 0x22f0
movq 0xa7a6(%rip), %rsi      # 0xdfe0
movq 0xa77f(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
leaq 0x59e8(%rip), %rdi      # 0x9238
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x385c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38e3
movl %edx, %r9d
movq (%rdi), %r10
movq 0x8(%rdi), %rax
subq %r10, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r8
leaq -0x1(%r8), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
cmpq %rcx, %rdx
jbe 0x3901
movl %r9d, %edx
leaq (%rcx,%rcx,2), %rax
addq %rdx, %rax
cmpq %rax, %r8
jbe 0x3933
leaq (%rax,%rax,4), %rax
movups (%rsi), %xmm0
leaq (%r10,%rax,8), %rdi
addq $0x10, %rdi
movups %xmm0, -0x10(%rdi)
addq $0x10, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x357c
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x58ba(%rip), %rsi      # 0x91b1
movq %rax, %rdi
callq 0x22f0
jmp 0x391d
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x58b8(%rip), %rsi      # 0x91cd
movq %rax, %rdi
callq 0x22f0
movq 0xa6bc(%rip), %rsi      # 0xdfe0
movq 0xa695(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
leaq 0x58fe(%rip), %rdi      # 0x9238
movq %rax, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x3949
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x357c
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x357c
movq %r15, %rdi
movq %rbp, %rsi
callq 0x357c
movq %r12, %rdi
movq %r13, %rsi
callq 0x357c
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
testq %rdi, %rdi
je 0x3a15
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x2321
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, 0x60(%rsp)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
movl $0x1, %edx
shll %cl, %edx
sarq $0x3, %rax
movslq %edx, %rcx
cmpq %rcx, %rax
jb 0x3baf
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
callq 0x3378
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3062
testq %r14, %r14
je 0x3b6f
xorl %r15d, %r15d
leaq 0x28(%rsp), %r12
leaq 0x40(%rsp), %r13
leaq 0x10(%rsp), %rbp
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r15, 0x50(%rsp)
movq %r15, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3c4a
movq %r12, %rdi
movq %r13, %rsi
callq 0x357c
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x34fa
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3b50
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3b67
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
incq %rbx
cmpq %rbx, %r14
jne 0x3af4
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdi
addq $-0x18, %rdi
leaq 0x28(%rsp), %rsi
callq 0x357c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3b9d
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x5627(%rip), %rsi      # 0x91ea
movq %rax, %rdi
callq 0x22f0
movq 0xa40e(%rip), %rsi      # 0xdfe0
movq 0xa3e7(%rip), %rdx      # 0xdfc0
movq %r14, %rdi
callq 0x22b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2140
jmp 0x3c42
movq %rax, %rbx
jmp 0x3c21
movq %rax, %rbx
jmp 0x3c38
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3c12
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2376
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3c38
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x8(%rsp), %rdi
callq 0x343a
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3062
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
leaq -0x1(%rbp), %rax
cmpq %r15, %rax
je 0x3dc9
addq $-0x3, %rbp
negq %r15
leaq 0x10(%rsp), %r14
movq 0x8(%rsp), %r13
cmpq $-0x1, %rbp
je 0x3d76
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3468
movq 0x8(%rax), %r13
subq (%rax), %r13
sarq $0x3, %r13
leaq 0x1(%rbp), %rsi
movq %r12, %rdi
callq 0x3468
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
movq %rax, %rcx
movq %r13, %r8
callq 0x3f86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5cfc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3db9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
leaq (%r15,%rbp), %rax
decq %rax
decq %rbp
cmpq $-0x2, %rax
jne 0x3d55
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ddd
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3df4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52e6(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rdi, %rbx
subpd 0x52eb(%rip), %xmm1     # 0x9120
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x52e7(%rip), %xmm0     # 0x9130
callq 0x2060
movapd %xmm0, 0x40(%rsp)
movq 0x60(%r12), %rcx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x51be
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0x5311
movapd 0x40(%rsp), %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %r14
movq %r14, %rax
subsd 0x529d(%rip), %xmm0     # 0x9138
cvttsd2si %xmm0, %r15
sarq $0x3f, %rax
andq %rax, %r15
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movupd 0x28(%rsp), %xmm0
movupd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x3ee7
subq %rdi, %rsi
callq 0x21d0
orq %r15, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f01
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rsi
shrq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x54ec
testq %r14, %r14
je 0x3f3a
movq 0x8(%rsp), %rax
movq (%rbx), %rcx
movl $0x1, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x4(%rcx,%rdx,4)
addq $0x2, %rdx
cmpq %r14, %rdx
jbe 0x3f26
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3f51
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3f64
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3f7e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5576
shrq %r13
movq %rsp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x51be
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5cfc
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4167
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x5311
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5cfc
movq (%r15), %rdi
testq %rdi, %rdi
je 0x419a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq (%rbx), %r15
leaq (%r15,%rbp), %r12
addq $-0x8, %r12
cmpq %r12, %r15
je 0x41d4
movq 0x8(%rbx), %rdx
subq %r12, %rdx
je 0x41be
movq %r15, %rdi
movq %r12, %rsi
callq 0x2270
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %r12, %rcx
addq %rcx, %r15
cmpq %r15, %rax
je 0x41d4
movq %r15, 0x8(%rbx)
shlq $0x3, %r14
addq (%rbx), %r14
movq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0x41fa
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
addq %rdx, %r14
cmpq %r14, %rcx
je 0x41fa
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x420e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4225
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdx, %r12
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movups -0x28(%rsi), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
addq $-0x18, %rsi
movq %rdi, 0x30(%rsp)
callq 0x3062
movq 0x8(%r12), %rcx
subq (%r12), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq %r14
cmpq %r15, %r14
je 0x462c
movq %r15, %r13
decq %r14
negq %r13
testq %r14, %r14
je 0x4593
leaq -0x1(%r14), %rdx
movq %r12, %rdi
movl $0x2, %esi
callq 0x379a
movq %rax, %rdi
callq 0x62b6
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
jmp 0x45a0
movq 0x28(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x379a
movq %rax, %rbp
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x379a
movq %rax, %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x379a
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r15, %r8
movq %rax, %r9
callq 0x49d2
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x357c
leaq 0x40(%rsp), %rdi
callq 0x6292
leaq (%r14,%r13), %rax
decq %rax
decq %r14
cmpq $-0x1, %rax
jne 0x4569
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4655
jmp 0x4655
jmp 0x4655
jmp 0x4655
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6292
jmp 0x4658
movq %rax, %r14
movq %rbx, %rdi
callq 0x6292
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3378
movq 0x8(%r14), %r15
movq %r14, 0x20(%rsp)
subq (%r14), %r15
sarq $0x3, %r15
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
je 0x4e5d
movq 0x10(%rsp), %rax
movq %rax, %r12
negq %r12
leal -0x1(%rax), %ebp
xorl %r14d, %r14d
leaq 0x50(%rsp), %rbx
leaq 0x38(%rsp), %r13
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movslq %eax, %rsi
imulq %r15, %rsi
movq $0x0, 0x30(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x4eee
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x34fa
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4e50
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
incq %r14
decl %ebp
movq %r12, %rax
addq %r14, %rax
jne 0x4e00
movq 0x40(%rsp), %rdi
addq $-0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x357c
movq 0x28(%rsp), %rbx
movl $0x1, %eax
movq 0x10(%rsp), %rcx
shll %cl, %eax
cltq
imulq %rax, %r15
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x3cf4
leaq 0x38(%rsp), %rdi
callq 0x343a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ebc
movq %rax, %rbx
jmp 0x4edb
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4edb
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
leaq 0x38(%rsp), %rdi
callq 0x343a
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x3660
movq %r12, %rdi
callq 0x62ac
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r12, %rdi
callq 0x62b0
movq %rax, %rbp
movq %r15, (%rsp)
testq %r15, %r15
je 0x5056
movq (%rsp), %rax
movq %rax, %r12
negq %r12
leal -0x1(%rax), %r14d
xorl %ebx, %ebx
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r13
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
movslq %eax, %rdx
movq 0x8(%rsp), %rsi
imulq %rdx, %rsi
imulq %rbp, %rdx
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6134
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3870
movq %r13, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3870
movq %r13, %rdi
movq %r15, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x3870
movq %r15, %rdi
callq 0x6292
incq %rbx
decl %r14d
movq %r12, %rax
addq %rbx, %rax
jne 0x4fe5
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movups (%rsi), %xmm0
movups %xmm0, -0x28(%rdi)
addq $-0x18, %rdi
addq $0x10, %rsi
callq 0x357c
movq (%rsp), %rcx
movl $0x1, %eax
shll %cl, %eax
cltq
movq 0x8(%rsp), %rcx
imulq %rax, %rcx
imulq %rax, %rbp
leaq 0x40(%rsp), %r8
movq %rcx, (%r8)
movq %rbp, 0x8(%r8)
leaq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
xorl %ecx, %ecx
callq 0x44e8
leaq 0x28(%rsp), %rdi
callq 0x375a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50d5
jmp 0x50d5
jmp 0x50d5
movq %rax, %rbx
jmp 0x50e7
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6292
leaq 0x28(%rsp), %rdi
callq 0x375a
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
decq %rcx
cmpq %r14, %rcx
jbe 0x5178
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %r14, %r14
sete %bpl
xorl %esi, %esi
movq %r14, %rax
subq $0x1, %rax
cmovaeq %rax, %rsi
movq %rdx, %rdi
callq 0x3468
movq 0x8(%rax), %r8
subq (%rax), %r8
xorb $0x3, %bpl
movl %ebp, %ecx
sarq %cl, %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3cf4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x406f(%rip), %rsi      # 0x91fb
movq %rax, %rdi
callq 0x22f0
movq 0x8e45(%rip), %rsi      # 0xdfe0
movq 0x8e1e(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3062
movl 0x8(%r15), %eax
subl (%r15), %eax
testb $0x8, %al
je 0x5214
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x5208
movsd -0x8(%rsi), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x5214
leaq -0x8(%rsi), %rdx
movq %rsp, %rdi
callq 0x5d3c
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
sarq $0x3, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rcx, %rax
imulq %r15, %rax
addq %rdx, %rax
leaq (%rcx,%rax,2), %rsi
movq %rbx, %rdi
callq 0x5756
movq (%rbx), %rsi
movq 0x8(%rsp), %rcx
leaq (,%r14,8), %rax
movq %rcx, %rdx
subq %rax, %rdx
movq %rbx, %rdi
callq 0x5f40
addq %r15, %r15
movq $-0x1, %r12
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x5f40
incq %r12
cmpq %r15, %r12
jb 0x527b
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
leaq (%rdx,%r14,8), %rcx
movq %rbx, %rdi
callq 0x5f40
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x52c2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x52f3
jmp 0x52dc
jmp 0x52dc
jmp 0x52dc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x52f3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5309
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
callq 0x5756
movq (%r14), %rdx
cmpq %rdx, 0x8(%r14)
je 0x562b
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x55da
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x55e2
movq %rbx, %rdi
callq 0x5d3c
movq $0x0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5606
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5611
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5e60
incq %r13
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq $0x3, %rax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x55bb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5640
jmp 0x5640
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5657
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
cmpq %rbx, %rdx
jbe 0x5711
movq %rsi, %r15
movq %rdi, %r12
testq %rbx, %rbx
je 0x56c8
leaq -0x1(%rbx), %rdx
movq %r14, %rdi
movl $0x2, %esi
callq 0x379a
movq %rax, %rdi
callq 0x62b6
jmp 0x56e5
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x379a
movq %rax, %rdi
callq 0x62b6
addq %rax, %rax
addq %rdx, %rdx
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x44e8
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x3ae7(%rip), %rsi      # 0x920c
movq %rax, %rdi
callq 0x22f0
movq 0x88ac(%rip), %rsi      # 0xdfe0
movq 0x8885(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rdx, %rax
imulq %rsi, %rax
movq 0x8(%rcx), %rdi
subq (%rcx), %rdi
sarq $0x3, %rdi
cmpq %rdi, %rax
jne 0x6223
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x357c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r12
leaq 0x30d5(%rip), %rsi      # 0x930c
movq %rax, %rdi
callq 0x22f0
movq 0x7d9a(%rip), %rsi      # 0xdfe0
movq 0x7d73(%rip), %rdx      # 0xdfc0
movq %r12, %rdi
callq 0x22b0
movq %rax, %r15
movq %r12, %rdi
callq 0x2140
jmp 0x6265
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6279
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x3026(%rip), %rsi      # 0x931b
movq %rax, %rdi
callq 0x2210
movq 0x7cd4(%rip), %rsi      # 0xdfd8
movq 0x7c9d(%rip), %rdx      # 0xdfa8
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6627
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
cmpq %rax, 0x8(%rdi)
jne 0x6627
cmpq $0x0, 0x8(%r15)
je 0x660a
movq %rdx, %rbx
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0x6616
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6404
movq %r15, %rdi
movq %rax, %rsi
callq 0x6480
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r12
cmpq 0x8(%r15), %r12
jb 0x65c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c1b(%rip), %rdi      # 0x9238
movq %r12, %rsi
xorl %eax, %eax
callq 0x2240
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x2d40(%rip), %rsi      # 0x937b
movq %rax, %rdi
callq 0x22f0
movq 0x7996(%rip), %rsi      # 0xdfe0
movq 0x796f(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x66c1
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
cmpq %rax, (%rdi)
jne 0x66c1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6404
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
je 0x66b9
shlq $0x3, %rax
addq 0x10(%rbx), %rax
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2270
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x2cb5(%rip), %rsi      # 0x938a
movq %rax, %rdi
callq 0x22f0
movq 0x78fc(%rip), %rsi      # 0xdfe0
movq 0x78d5(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x5756
cmpq $0x0, 0x8(%r15)
je 0x67fb
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6404
movq %r15, %rdi
movq %rax, %rsi
callq 0x6502
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x67e7
movsd (%rax), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x67f2
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5d3c
incq %r12
cmpq 0x8(%r15), %r12
jb 0x67b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x680c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6823
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x691e
movq %rsi, %r14
movq $-0x1, %r15
xorl %r12d, %r12d
addq %r15, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6404
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
leaq (%rcx,%rax,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x690a
leaq (%rcx,%rax,8), %rdi
subq %rsi, %rdx
callq 0x2270
addq $-0x8, 0x18(%rbx)
incq %r12
movq 0x8(%rbx), %rdx
decq %r15
cmpq %rdx, %r12
jb 0x68db
decq (%rbx)
movq %rbx, %rdi
callq 0x6326
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6946
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2a5f(%rip), %rdi      # 0x93ac
leaq 0x2a70(%rip), %rsi      # 0x93c4
leaq 0x2a74(%rip), %rcx      # 0x93cf
movl $0xb8, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
xorl %esi, %esi
movq %r15, %rdx
callq 0x6404
movq %rax, %r14
incq %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x6404
cmpq %rax, %r14
je 0x69c9
movq 0x10(%rbx), %rcx
leaq (%rcx,%r14,8), %r14
leaq (%rcx,%rax,8), %r15
movq 0x18(%rbx), %rdx
subq %r15, %rdx
je 0x69b3
movq %r14, %rdi
movq %r15, %rsi
callq 0x2270
movq 0x18(%rbx), %rax
movq %rax, %rcx
subq %r15, %rcx
addq %rcx, %r14
cmpq %r14, %rax
je 0x69c9
movq %r14, 0x18(%rbx)
decq 0x8(%rbx)
movq %rbx, %rdi
callq 0x6326
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x69ec
popq %rbx
popq %r14
popq %r15
retq
leaq 0x29b9(%rip), %rdi      # 0x93ac
leaq 0x29ca(%rip), %rsi      # 0x93c4
leaq 0x2a02(%rip), %rcx      # 0x9403
movl $0xc1, %edx
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq %r15, %rsi
callq 0x5756
testq %r15, %r15
je 0x6a8e
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x6404
movq %r14, %rdi
movq %rax, %rsi
callq 0x6502
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6a7b
movsd (%rax), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a86
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5d3c
incq %r12
cmpq %r12, %r15
jne 0x6a46
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6a9f
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6ab6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6cea
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x6ce0
xorl %r14d, %r14d
cmpq $0x0, (%rbx)
je 0x6cd7
xorl %r15d, %r15d
movsd 0x264a(%rip), %xmm0     # 0x92e8
cmpq %r15, %r14
je 0x6ca6
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6404
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6480
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r15
cmpq (%rbx), %r15
jb 0x6c96
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x6c8d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x273c(%rip), %rsi      # 0x943a
movq %rax, %rdi
callq 0x2210
movq 0x72cb(%rip), %rsi      # 0xdfd8
movq 0x7294(%rip), %rdx      # 0xdfa8
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rbx), %rsi
imulq (%rbx), %rsi
callq 0x5756
cmpq $0x0, (%rbx)
je 0x6dc6
xorl %r14d, %r14d
movq %rsp, %r15
cmpq $0x0, 0x8(%rbx)
je 0x6dbe
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6404
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6480
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x6daa
movsd (%rax), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x6db5
movq %r15, %rdi
movq %rax, %rdx
callq 0x5d3c
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x6d72
incq %r14
cmpq (%rbx), %r14
jb 0x6d68
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x357c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6326
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6e1b
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e0f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x258a(%rip), %rdi      # 0x93ac
leaq 0x259b(%rip), %rsi      # 0x93c4
leaq 0x261b(%rip), %rcx      # 0x944b
movl $0x101, %edx            # imm = 0x101
callq 0x2110
jmp 0x6e3c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e55
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6326
cmpq %rax, %r12
jne 0x6eac
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6326
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x6ede
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x25b9(%rip), %rsi      # 0x9479
movq %rax, %rdi
callq 0x22f0
movq 0x7111(%rip), %rsi      # 0xdfe0
movq 0x70ea(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
leaq 0x24c7(%rip), %rdi      # 0x93ac
leaq 0x24d8(%rip), %rsi      # 0x93c4
leaq 0x2596(%rip), %rcx      # 0x9489
movl $0x10b, %edx            # imm = 0x10B
callq 0x2110
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62b6
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r14, %rdi
callq 0x62b6
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movdqu 0x18(%rsp), %xmm0
movdqu 0x8(%rsp), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x722f
addq $0x10, %r15
leaq 0x10(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7274
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
movq %r12, %rsi
callq 0x3062
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x2292(%rip), %rsi      # 0x94d5
movq %rax, %rdi
callq 0x22f0
movq 0x6d8e(%rip), %rsi      # 0xdfe0
movq 0x6d67(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0