LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::computeOutputSoftmax(fasttext::Vector&, fasttext::Vector&) const
void Model::computeOutputSoftmax(Vector& hidden, Vector& output) const {
  output.mul(*wo_, hidden);
  real max = output[0], z = 0.0;
  for (int32_t i = 0; i < osz_; i++) {
    max = std::max(output[i], max);
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] = exp(output[i] - max);
    z += output[i];
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] /= z;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rdi
callq 0x15a10
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x13580
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13750
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x1447e
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x13750
movq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x15ad0
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14442
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x144f8
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x13750
movss (%rax), %xmm0
subss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x45d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x13750
movss -0x44(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x13750
movss (%rax), %xmm0
addss -0x20(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x14485
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x14541
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x13750
movss -0x48(%rbp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x144ff
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::computeHidden(std::vector<int, std::allocator<int>> const&, fasttext::Vector&) const
void Model::computeHidden(const std::vector<int32_t>& input, Vector& hidden) const {
  assert(hidden.size() == hsz_);
  hidden.zero();
  for (auto it = input.cbegin(); it != input.cend(); ++it) {
    hidden.addRow(*wi_, *it);
  }
  hidden.mul(1.0 / input.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13200
movq -0x30(%rbp), %rcx
movslq 0x78(%rcx), %rcx
cmpq %rcx, %rax
jne 0x14704
jmp 0x14723
leaq 0x153ad(%rip), %rdi     # 0x29ab8
leaq 0x153bc(%rip), %rsi     # 0x29ace
movl $0x7d, %edx
leaq 0x153bd(%rip), %rcx     # 0x29adb
callq 0x41d0
movq -0x18(%rbp), %rdi
callq 0x13180
movq -0x10(%rbp), %rdi
callq 0x15b10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15b40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13840
testb $0x1, %al
jne 0x14759
jmp 0x14792
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x15a10
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x13880
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq (%rax), %rdx
callq 0x132d0
leaq -0x20(%rbp), %rdi
callq 0x138a0
jmp 0x14739
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad50
movq -0x48(%rbp), %rdi
movq %rax, %xmm1
movaps 0x14e4d(%rip), %xmm0    # 0x29600
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x14e51(%rip), %xmm0    # 0x29610
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x14df2(%rip), %xmm0    # 0x295c8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x13270
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::updatePolarization(int, float)
void Model::updatePolarization(int32_t w, real lr) {
  assert(w >= 0);
  assert(w < osz_);
  loss_ += polarization(w, lr);
  wi_->addRow(grad_, w, 1.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x14fa4
jmp 0x14fc3
leaq 0x14c74(%rip), %rdi     # 0x29c1f
leaq 0x14b1c(%rip), %rsi     # 0x29ace
movl $0xdd, %edx
leaq 0x14c68(%rip), %rcx     # 0x29c26
callq 0x41d0
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x14fd4
jmp 0x14ff3
leaq 0x14c83(%rip), %rdi     # 0x29c5e
leaq 0x14aec(%rip), %rsi     # 0x29ace
movl $0xde, %edx
leaq 0x14c38(%rip), %rcx     # 0x29c26
callq 0x41d0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
callq 0x14050
movq -0x18(%rbp), %rdi
addss 0x84(%rdi), %xmm0
movss %xmm0, 0x84(%rdi)
callq 0x15820
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x68, %rsi
movslq -0xc(%rbp), %rdx
movss 0x14924(%rip), %xmm0    # 0x29958
callq 0x12ba0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::setTargetCounts(std::vector<long, std::allocator<long>> const&)
void Model::setTargetCounts(const std::vector<int64_t>& counts) {
  assert(counts.size() == osz_);
 // init negative table for both ns and polar (ddu)  
  if (args_->loss == loss_name::ns || args_->loss == loss_name::polar) {
    initTableNegatives(counts);
  }
  if (args_->loss == loss_name::hs) {
    buildTree(counts);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f90
movq -0x18(%rbp), %rcx
movslq 0x80(%rcx), %rcx
cmpq %rcx, %rax
jne 0x15073
jmp 0x15092
leaq 0x14bed(%rip), %rdi     # 0x29c67
leaq 0x14a4d(%rip), %rsi     # 0x29ace
movl $0xe4, %edx
leaq 0x14bf0(%rip), %rcx     # 0x29c7d
callq 0x41d0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xa170
cmpl $0x2, 0x88(%rax)
je 0x150be
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xa170
cmpl $0x4, 0x88(%rax)
jne 0x150cb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15100
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xa170
cmpl $0x1, 0x88(%rax)
jne 0x150ee
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x152c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::getVector(fasttext::Vector&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FastText::getVector(Vector& vec, const std::string& word) {
  const std::vector<int32_t>& ngrams = dict_->getNgrams(word);
  vec.zero();
  for (auto it = ngrams.begin(); it != ngrams.end(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (ngrams.size() > 0) {
    vec.mul(1.0 / ngrams.size());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x10, %rdi
callq 0x1ff50
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6f20
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13180
jmp 0x1c51f
movq -0x20(%rbp), %rdi
callq 0xd9b0
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd9e0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13840
testb $0x1, %al
jne 0x1c54c
jmp 0x1c5a4
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x20, %rdi
callq 0x15a10
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x13880
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movslq (%rax), %rdx
callq 0x132d0
jmp 0x1c580
jmp 0x1c582
leaq -0x50(%rbp), %rdi
callq 0x138a0
jmp 0x1c52c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa040
jmp 0x1c61a
movq -0x20(%rbp), %rdi
callq 0xad50
cmpq $0x0, %rax
jbe 0x1c608
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0xad50
movq -0x80(%rbp), %rdi
movq %rax, %xmm1
movaps 0xd02c(%rip), %xmm0     # 0x29600
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xd030(%rip), %xmm0     # 0x29610
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0xcfd1(%rip), %xmm0     # 0x295c8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x13270
jmp 0x1c606
jmp 0x1c608
leaq -0x38(%rbp), %rdi
callq 0xa040
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::saveModel()
void FastText::saveModel() {
  std::ofstream ofs(args_->output + ".bin", std::ofstream::binary);
  if (!ofs.is_open()) {
    std::cerr << "Model file cannot be opened for saving!" << std::endl;
    exit(EXIT_FAILURE);
  }
  args_->save(ofs);
  dict_->save(ofs);
  input_->save(ofs);
  output_->save(ofs);
  ofs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0xa170
movq %rax, %rsi
addq $0x40, %rsi
leaq 0xd387(%rip), %rdx      # 0x29d34
leaq -0x228(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x1ff70
movq -0x240(%rbp), %rsi
leaq -0x208(%rbp), %rdi
movl $0x4, %edx
callq 0x4640
jmp 0x1c9da
leaq -0x228(%rbp), %rdi
callq 0x4688
leaq -0x208(%rbp), %rdi
callq 0x4240
movb %al, -0x249(%rbp)
jmp 0x1c9fa
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x1ca8b
jmp 0x1ca0a
movq 0x1f5df(%rip), %rdi     # 0x3bff0
leaq 0xd321(%rip), %rsi      # 0x29d39
callq 0x42e0
movq %rax, -0x258(%rbp)
jmp 0x1ca26
movq -0x258(%rbp), %rdi
movq 0x1f564(%rip), %rsi     # 0x3bf98
callq 0x4310
jmp 0x1ca3b
movl $0x1, %edi
callq 0x4390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x4688
jmp 0x1cb2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x44c0
jmp 0x1cb2e
movq -0x248(%rbp), %rdi
callq 0xa170
movq %rax, %rdi
leaq -0x208(%rbp), %rsi
callq 0x5f70
jmp 0x1caa8
movq -0x248(%rbp), %rdi
addq $0x10, %rdi
callq 0x1ff50
movq %rax, %rdi
leaq -0x208(%rbp), %rsi
callq 0x83b0
jmp 0x1cac9
movq -0x248(%rbp), %rdi
addq $0x20, %rdi
callq 0x15820
movq %rax, %rdi
leaq -0x208(%rbp), %rsi
callq 0x12dd0
jmp 0x1caea
movq -0x248(%rbp), %rdi
addq $0x30, %rdi
callq 0x15820
movq %rax, %rdi
leaq -0x208(%rbp), %rsi
callq 0x12dd0
jmp 0x1cb0b
leaq -0x208(%rbp), %rdi
callq 0x44a0
jmp 0x1cb19
leaq -0x208(%rbp), %rdi
callq 0x44c0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x45b0
nopw (%rax,%rax)
// File: ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FastText::loadModel(const std::string& filename) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  loadModel(ifs);
  ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x230(%rbp)
movl $0x4, %edx
callq 0x4510
movq -0x230(%rbp), %rdi
callq 0x4500
movb %al, -0x225(%rbp)
jmp 0x1cb8e
movb -0x225(%rbp), %al
testb $0x1, %al
jne 0x1cbf5
jmp 0x1cb9a
movq 0x1f44f(%rip), %rdi     # 0x3bff0
leaq 0xd1b9(%rip), %rsi      # 0x29d61
callq 0x42e0
movq %rax, -0x240(%rbp)
jmp 0x1cbb6
movq -0x240(%rbp), %rdi
movq 0x1f3d4(%rip), %rsi     # 0x3bf98
callq 0x4310
jmp 0x1cbcb
movl $0x1, %edi
callq 0x4390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4090
jmp 0x1cc2d
movq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1cc40
jmp 0x1cc0a
leaq -0x218(%rbp), %rdi
callq 0x4080
jmp 0x1cc18
leaq -0x218(%rbp), %rdi
callq 0x4090
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::istream&)
void FastText::loadModel(std::istream& in) {
  args_ = std::make_shared<Args>();
  dict_ = std::make_shared<Dictionary>(args_);
  input_ = std::make_shared<Matrix>();
  output_ = std::make_shared<Matrix>();
  args_->load(in);
  dict_->load(in);
  input_->load(in);
  output_->load(in);
  model_ = std::make_shared<Model>(input_, output_, args_, 0);
  if (args_->model == model_name::sup) {
    model_->setTargetCounts(dict_->getCounts(entry_type::label));
  } else {
    model_->setTargetCounts(dict_->getCounts(entry_type::word));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1fff0
movq -0xb0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20060
leaq -0x20(%rbp), %rdi
callq 0xa0a0
movq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x20090
movq -0xb0(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0x20100
leaq -0x30(%rbp), %rdi
callq 0x20130
leaq -0x40(%rbp), %rdi
callq 0x20150
movq -0xb0(%rbp), %rdi
addq $0x20, %rdi
leaq -0x40(%rbp), %rsi
callq 0x201c0
leaq -0x40(%rbp), %rdi
callq 0x159f0
leaq -0x50(%rbp), %rdi
callq 0x20150
movq -0xb0(%rbp), %rdi
addq $0x30, %rdi
leaq -0x50(%rbp), %rsi
callq 0x201c0
leaq -0x50(%rbp), %rdi
callq 0x159f0
movq -0xb0(%rbp), %rdi
callq 0xa170
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x60c0
movq -0xb0(%rbp), %rdi
addq $0x10, %rdi
callq 0x1ff50
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8530
movq -0xb0(%rbp), %rdi
addq $0x20, %rdi
callq 0x15820
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x12e40
movq -0xb0(%rbp), %rdi
addq $0x30, %rdi
callq 0x15820
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x12e40
movq -0xb0(%rbp), %rcx
movq %rcx, %rsi
addq $0x20, %rsi
movq %rcx, %rdx
addq $0x30, %rdx
movl $0x0, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %r8
callq 0x201f0
movq -0xb0(%rbp), %rdi
addq $0x40, %rdi
leaq -0x60(%rbp), %rsi
callq 0x20280
leaq -0x60(%rbp), %rdi
callq 0x202b0
movq -0xb0(%rbp), %rdi
callq 0xa170
cmpl $0x3, 0x8c(%rax)
jne 0x1ce46
movq -0xb0(%rbp), %rdi
addq $0x40, %rdi
callq 0x202d0
movq -0xb0(%rbp), %rdi
movq %rax, -0xc0(%rbp)
addq $0x10, %rdi
callq 0x1ff50
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x1, %edx
callq 0x7e80
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x15040
jmp 0x1ce18
leaq -0x80(%rbp), %rdi
callq 0xacf0
jmp 0x1cec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xacf0
jmp 0x1ced1
movq -0xb0(%rbp), %rdi
addq $0x40, %rdi
callq 0x202d0
movq -0xb0(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x10, %rdi
callq 0x1ff50
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
xorl %edx, %edx
callq 0x7e80
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x15040
jmp 0x1ce9a
leaq -0xa8(%rbp), %rdi
callq 0xacf0
jmp 0x1cec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xacf0
jmp 0x1ced1
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::printVectors()
void FastText::printVectors() {
  if (args_->model == model_name::sup) {
    textVectors();
  } else {
    wordVectors();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xa170
cmpl $0x3, 0x8c(%rax)
jne 0x1e51d
movq -0x10(%rbp), %rdi
callq 0x1e2a0
jmp 0x1e526
movq -0x10(%rbp), %rdi
callq 0x1e170
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ddu1[P]polarizedtext/src/main.cc
// Function: printUsage()
void printUsage() {
  std::cout
    << "usage: fasttext <command> <args>\n\n"
    << "The commands supported by fasttext are:\n\n"
    << "  supervised          train a supervised classifier\n"
    << "  test                evaluate a supervised classifier\n"
    << "  predict             predict most likely labels\n"
    << "  predict-prob        predict most likely labels with probabilities\n"
    << "  skipgram            train a skipgram model\n"
    << "  cbow                train a cbow model\n"
    << "  print-vectors       print vectors given a trained model\n"
    << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x148c5(%rip), %rdi     # 0x3bfc0
leaq 0x29ee(%rip), %rsi      # 0x2a0f0
callq 0x42e0
movq %rax, %rdi
leaq 0x2a02(%rip), %rsi      # 0x2a113
callq 0x42e0
movq %rax, %rdi
leaq 0x2a1d(%rip), %rsi      # 0x2a13d
callq 0x42e0
movq %rax, %rdi
leaq 0x2a43(%rip), %rsi      # 0x2a172
callq 0x42e0
movq %rax, %rdi
leaq 0x2a6c(%rip), %rsi      # 0x2a1aa
callq 0x42e0
movq %rax, %rdi
leaq 0x2a8f(%rip), %rsi      # 0x2a1dc
callq 0x42e0
movq %rax, %rdi
leaq 0x2ac5(%rip), %rsi      # 0x2a221
callq 0x42e0
movq %rax, %rdi
leaq 0x2ae4(%rip), %rsi      # 0x2a24f
callq 0x42e0
movq %rax, %rdi
leaq 0x2aff(%rip), %rsi      # 0x2a279
callq 0x42e0
movq %rax, %rdi
movq 0x1480f(%rip), %rsi     # 0x3bf98
callq 0x4310
popq %rbp
retq
// File: ddu1[P]polarizedtext/src/main.cc
// Function: printTestUsage()
void printTestUsage() {
  std::cout
    << "usage: fasttext test <model> <test-data> [<k>]\n\n"
    << "  <model>      model filename\n"
    << "  <test-data>  test data filename (if -, read from stdin)\n"
    << "  <k>          (optional; 1 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x14825(%rip), %rdi     # 0x3bfc0
leaq 0x2b12(%rip), %rsi      # 0x2a2b4
callq 0x42e0
movq %rax, %rdi
leaq 0x2b34(%rip), %rsi      # 0x2a2e5
callq 0x42e0
movq %rax, %rdi
leaq 0x2b44(%rip), %rsi      # 0x2a304
callq 0x42e0
movq %rax, %rdi
leaq 0x2b70(%rip), %rsi      # 0x2a33f
callq 0x42e0
movq %rax, %rdi
movq 0x147ba(%rip), %rsi     # 0x3bf98
callq 0x4310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/main.cc
// Function: printPredictUsage()
void printPredictUsage() {
  std::cout
    << "usage: fasttext predict[-prob] <model> <test-data> [<k>]\n\n"
    << "  <model>      model filename\n"
    << "  <test-data>  test data filename (if -, read from stdin)\n"
    << "  <k>          (optional; 1 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x147c5(%rip), %rdi     # 0x3bfc0
leaq 0x2b7b(%rip), %rsi      # 0x2a37d
callq 0x42e0
movq %rax, %rdi
leaq 0x2ad4(%rip), %rsi      # 0x2a2e5
callq 0x42e0
movq %rax, %rdi
leaq 0x2ae4(%rip), %rsi      # 0x2a304
callq 0x42e0
movq %rax, %rdi
leaq 0x2b10(%rip), %rsi      # 0x2a33f
callq 0x42e0
movq %rax, %rdi
movq 0x1475a(%rip), %rsi     # 0x3bf98
callq 0x4310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/main.cc
// Function: printPrintVectorsUsage()
void printPrintVectorsUsage() {
  std::cout
    << "usage: fasttext print-vectors <model>\n\n"
    << "  <model>      model filename\n"
    << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x14765(%rip), %rdi     # 0x3bfc0
leaq 0x2b56(%rip), %rsi      # 0x2a3b8
callq 0x42e0
movq %rax, %rdi
leaq 0x2a74(%rip), %rsi      # 0x2a2e5
callq 0x42e0
movq %rax, %rdi
movq 0x14718(%rip), %rsi     # 0x3bf98
callq 0x4310
popq %rbp
retq
nopw (%rax,%rax)
// File: ddu1[P]polarizedtext/src/main.cc
// Function: printVectors(int, char**)
void printVectors(int argc, char** argv) {
  if (argc != 3) {
    printPrintVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printVectors();
  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
je 0x27ec7
callq 0x27850
movl $0x1, %edi
callq 0x4390
leaq -0x70(%rbp), %rdi
callq 0x282c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x45c0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x6210
jmp 0x27f0e
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1cb40
jmp 0x27f20
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4330
leaq -0x70(%rbp), %rdi
callq 0x1e4f0
jmp 0x27f43
xorl %edi, %edi
callq 0x4390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x27f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4330
jmp 0x27f9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x28320
movq -0xa0(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/Animal.cc
// Function: main
int main() {
	Panda ying_yang("ying_yang");
	
	print(ying_yang);     // passes Panda to a reference to Bear
	highlight(ying_yang); // passes Panda to a reference to Endangered
	cout << ying_yang << endl; // passes Panda to a reference to ZooAnimal
	Panda ling_ling = ying_yang;    // uses the copy constructor 

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x20f0
movq -0x108(%rbp), %rdx
leaq 0xd1b(%rip), %rsi       # 0x304e
leaq -0x88(%rbp), %rdi
callq 0x20c0
jmp 0x2341
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %edx
callq 0x2590
jmp 0x2358
leaq -0x88(%rbp), %rdi
callq 0x2060
leaq -0x89(%rbp), %rdi
callq 0x20b0
leaq -0x68(%rbp), %rdi
callq 0x2240
jmp 0x237b
leaq -0x10(%rbp), %rdi
callq 0x2280
jmp 0x2386
movq 0x2c4b(%rip), %rdi      # 0x4fd8
leaq -0x68(%rbp), %rsi
callq 0x22c0
movq %rax, -0x110(%rbp)
jmp 0x239f
movq -0x110(%rbp), %rdi
movq 0x2c1b(%rip), %rsi      # 0x4fc8
callq 0x20a0
jmp 0x23b4
leaq -0x100(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x26a0
jmp 0x23c6
movl $0x0, -0x4(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x2700
leaq -0x68(%rbp), %rdi
callq 0x2700
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x2420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2060
leaq -0x89(%rbp), %rdi
callq 0x20b0
jmp 0x2449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2700
movq -0x98(%rbp), %rdi
callq 0x20e0
nopw %cs:(%rax,%rax)
nop
// File: ef-gy[P]libefgy/include/ef.gy/statistics.h
// Function: std::optional<int> efgy::statistics::average<int>(std::vector<int, std::allocator<int>> const&)
static std::optional<Q> average(const std::vector<Q> &input) {
  if (input.size() == 0) {
    return std::optional<Q>();
  }

  Q s = 0;
  for (const Q &i : input) {
    s += i;
  }
  return std::optional<Q>(s / Q(input.size()));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33ef0
cmpq $0x0, %rax
jne 0x6809
leaq -0x8(%rbp), %rdi
callq 0x33f10
jmp 0x6891
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33f30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33f60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33f90
testb $0x1, %al
jne 0x6845
jmp 0x6869
leaq -0x28(%rbp), %rdi
callq 0x33fd0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33ff0
jmp 0x6832
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33ef0
movq %rax, %rcx
movl -0x40(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x34010
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/statistics.h
// Function: std::optional<double> efgy::statistics::variance<double, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>>(__gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>> const&)
static std::optional<T> variance(_InputIterator begin,
                                 const _InputIterator &end) {
  if (begin == end) {
    return std::optional<T>();
  }

  T sum = std::accumulate(begin, end, 0.0);
  T sum_square = std::accumulate(begin, end, 0.0, [](T first, T element) {
    return first + element * element;
  });
  unsigned int count_elements = end - begin;

  T var = (sum_square - sum * sum / count_elements) / count_elements;

  return std::optional<T>(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x35380
testb $0x1, %al
jne 0x6913
jmp 0x6921
leaq -0x10(%rbp), %rdi
callq 0x34a30
jmp 0x69bf
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x353c0
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
movsd %xmm1, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x6fc0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x35420
movl %eax, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm2
movl -0x58(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x34af0
movsd -0x10(%rbp), %xmm0
movb -0x8(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/statistics.h
// Function: std::optional<double> efgy::statistics::chi_square<double, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>>(__gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>)
static std::optional<T> chi_square(_InputIterator begin, _InputIterator end,
                                   _InputIterator measurement_begin,
                                   _InputIterator measurement_end) {
  T var = *variance<double>(measurement_begin, measurement_end);
  // TODO Check for 0 variances.
  if (begin == end) {
    return std::optional<T>();
  }

  unsigned int count_elements = end - begin;

  T sum = 0.0;
  for (; begin != end && measurement_begin != measurement_end;
       ++begin, ++measurement_begin) {
    sum += efgy::math::numeric::pow2((*measurement_begin - *begin) / (T)var);
  }

  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6e40
movsd %xmm0, -0x48(%rbp)
movb %al, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x354f0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x349f0
testb $0x1, %al
jne 0x70bd
jmp 0x70cb
leaq -0x10(%rbp), %rdi
callq 0x34a30
jmp 0x717c
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x34ab0
movl %eax, -0x54(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x34bb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x70fe
jmp 0x710e
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34bb0
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x7117
jmp 0x716f
leaq -0x28(%rbp), %rdi
callq 0x34bf0
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x34bf0
movsd -0x78(%rbp), %xmm0
subsd (%rax), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35510
addsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x34c10
leaq -0x28(%rbp), %rdi
callq 0x34c10
jmp 0x70e3
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x35530
movsd -0x10(%rbp), %xmm0
movb -0x8(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: dumpDNA(int, unsigned short, unsigned char*)
int dumpDNA (int i2c_file, uint16_t port_addr, uint8_t *data)
{
	uint16_t dna_length;

	if (i2cRead(i2c_file, port_addr, 0x8000, 2, 2, (uint8_t *)&dna_length) != 0) {
		return -1;
	}

	if (dna_length > 1318) {
		printf("Invalid DNA Length\n");
		exit(EXIT_FAILURE);
	}

	if (readMCU(i2c_file, port_addr, 0x8000, data, dna_length) != 0) {
		return -1;
	}

	return dna_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movzwl -0xa(%rbp), %esi
movl $0x8000, %edx           # imm = 0x8000
movl $0x2, %r8d
leaq -0x1a(%rbp), %r9
movl %r8d, %ecx
callq 0x3750
cmpl $0x0, %eax
je 0x39c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a17
movzwl -0x1a(%rbp), %eax
cmpl $0x526, %eax            # imm = 0x526
jle 0x39e5
leaq 0x10978(%rip), %rdi     # 0x1434c
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3320
movl -0x8(%rbp), %edi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rcx
movzwl -0x1a(%rbp), %r8d
movl $0x8000, %edx           # imm = 0x8000
movzwl %ax, %esi
callq 0x38d0
cmpl $0x0, %eax
je 0x3a10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a17
movzwl -0x1a(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xae248(%rip), %rdi     # 0x11b7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x59433(%rip), %rsi     # 0xc69b1
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq 0x4af50(%rip), %rsi     # 0xb84e8
leaq -0x14(%rbp), %rdx
callq 0x6dd30
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6de70
movq -0x6e8(%rbp), %rdi
movl $0x32, %esi
callq 0x6df10
jmp 0x6d5ce
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e330
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e330
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3550
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc1f6
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movslq -0x34(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x48a0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc1c7
leaq -0x30(%rbp), %rdi
leaq 0x6ebf(%rip), %rsi      # 0x130c0
callq 0x41b0
cmpl $0x0, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32c0
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>> Vector::operator-<double>(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator-(std::vector<T> vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator-");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::minus<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x32cb
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0xee6e(%rip), %rsi      # 0x12104
callq 0x2380
jmp 0x329d
movq -0x80(%rbp), %rdi
movq 0x16d38(%rip), %rsi     # 0x19fe0
movq 0x16d11(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x3332
movq -0x78(%rbp), %rdi
callq 0x45b0
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4270
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x45b0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x4510
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, -0x58(%rbp)
callq 0x4610
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>> Vector::operator*<double>(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator*(std::vector<T> vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator*");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::multiplies<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x49bb
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0xd794(%rip), %rsi      # 0x1211a
callq 0x2380
jmp 0x498d
movq -0x80(%rbp), %rdi
movq 0x15648(%rip), %rsi     # 0x19fe0
movq 0x15621(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x4a22
movq -0x78(%rbp), %rdi
callq 0x45b0
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4270
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x45b0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x4ad0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, -0x58(%rbp)
callq 0x4610
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0xc(%rbp)
je 0x5540
cmpl $0x1, -0xc(%rbp)
je 0x5540
cmpl $0x0, -0xc(%rbp)
je 0x5540
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xcc90(%rip), %rsi      # 0x12198
callq 0x2380
jmp 0x550f
movq -0x40(%rbp), %rdi
movq 0x14ac6(%rip), %rsi     # 0x19fe0
movq 0x14a9f(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x55cc
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x5400
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jb 0x55ad
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xcc3c(%rip), %rsi      # 0x121b4
callq 0x2380
jmp 0x557f
movq -0x50(%rbp), %rdi
movq 0x14a56(%rip), %rsi     # 0x19fe0
movq 0x14a2f(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2170
jmp 0x55cc
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
imulq $0x3, -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x55e0
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x14(%rbp)
je 0x56a4
cmpl $0x1, -0x14(%rbp)
je 0x56a4
cmpl $0x0, -0x14(%rbp)
je 0x56a4
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0xcb65(%rip), %rsi      # 0x121d1
callq 0x2380
jmp 0x5673
movq -0x48(%rbp), %rdi
movq 0x14962(%rip), %rsi     # 0x19fe0
movq 0x1493b(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x5744
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x5400
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0x5711
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0xcb11(%rip), %rsi      # 0x121ed
callq 0x2380
jmp 0x56e3
movq -0x58(%rbp), %rdi
movq 0x148f2(%rip), %rsi     # 0x19fe0
movq 0x148cb(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x5744
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
imulq $0x3, -0x20(%rbp), %rsi
addq -0x38(%rbp), %rsi
callq 0x5750
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x5790
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x5970
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5970
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x5970
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5970
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4fa0
jmp 0x58d2
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x4fa0
jmp 0x58e5
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0x4fa0
jmp 0x58f8
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x48, %rdi
callq 0x4fa0
jmp 0x590b
movq -0x60(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
shrq %rcx
movq %rcx, 0x60(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3430
movq -0x50(%rbp), %rdi
callq 0x3430
movq -0x58(%rbp), %rdi
callq 0x3430
movq -0x40(%rbp), %rdi
callq 0x3430
movq -0x30(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq -0x20(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x5a91
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0xc7b7(%rip), %rsi      # 0x1220a
callq 0x2380
jmp 0x5a5a
movq -0xa0(%rbp), %rdi
movq 0x14578(%rip), %rsi     # 0x19fe0
movq 0x14551(%rip), %rdx     # 0x19fc0
callq 0x2330
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2170
jmp 0x5be6
movq -0x98(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
movq -0x20(%rbp), %rsi
callq 0x4ba0
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x5ab4
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5b80
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5970
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5970
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0x48(%rbp), %rsi
callq 0x5bf0
jmp 0x5b0a
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4fa0
jmp 0x5b19
movq -0x98(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq -0x80(%rbp), %rsi
callq 0x4ec0
jmp 0x5b2f
leaq -0x80(%rbp), %rdi
callq 0x3430
leaq -0x68(%rbp), %rdi
callq 0x3430
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x5abc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x5bda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3430
leaq -0x68(%rbp), %rdi
callq 0x3430
jmp 0x5bb3
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x51f0
jmp 0x5b92
movb $0x1, -0x2d(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3430
testb $0x1, -0x2d(%rbp)
jne 0x5bca
jmp 0x5bbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3430
jmp 0x5bda
movq -0x98(%rbp), %rdi
callq 0x4d10
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4d10
movq -0x28(%rbp), %rdi
callq 0x2350
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d80
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3340
movq -0x18(%rbp), %rdi
callq 0x4d30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x5dd7
cmpq $0x1, -0x38(%rbp)
je 0x5d4c
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $-0x2, %rsi
callq 0x4de0
movq %rax, -0x88(%rbp)
jmp 0x5d37
movq -0x88(%rbp), %rdi
callq 0x31e0
movq %rax, -0x90(%rbp)
jmp 0x5d57
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
decq %rsi
callq 0x4de0
movq %rax, -0x98(%rbp)
jmp 0x5d7b
movq -0x98(%rbp), %rcx
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rsi
movq -0x40(%rbp), %r8
leaq -0x68(%rbp), %rdi
callq 0x6030
jmp 0x5d99
movq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6000
leaq -0x68(%rbp), %rdi
callq 0x3430
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5d08
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3430
jmp 0x5df7
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x5dea
movq -0x70(%rbp), %rdi
callq 0x3430
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2350