LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long, float)
void Vector::addRow(const Matrix& A, int64_t i, real a) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += a * A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x7e8c
cmpq %rdx, 0x8(%rsi)
jle 0x7ea5
movq (%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7ebe
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
testq %rax, %rax
cmovleq %rsi, %rax
cmpq %rsi, %rax
je 0x7e8a
movss (%rdx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rcx,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
jmp 0x7e6d
popq %rax
retq
leaq 0x7794(%rip), %rdi      # 0xf627
leaq 0x7ae3(%rip), %rsi      # 0xf97d
leaq 0x7b75(%rip), %rcx      # 0xfa16
pushq $0x4a
jmp 0x7ed5
leaq 0x7b56(%rip), %rdi      # 0xfa02
leaq 0x7aca(%rip), %rsi      # 0xf97d
leaq 0x7b5c(%rip), %rcx      # 0xfa16
pushq $0x4b
jmp 0x7ed5
leaq 0x7b46(%rip), %rdi      # 0xfa0b
leaq 0x7ab1(%rip), %rsi      # 0xf97d
leaq 0x7b43(%rip), %rcx      # 0xfa16
pushq $0x4c
popq %rdx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::mul(fasttext::Matrix const&, fasttext::Vector const&)
void Vector::mul(const Matrix& A, const Vector& vec) {
  assert(A.m_ == m_);
  assert(A.n_ == vec.m_);
  for (int64_t i = 0; i < m_; i++) {
    data_[i] = 0.0;
    for (int64_t j = 0; j < A.n_; j++) {
      data_[i] += A.data_[i * A.n_ + j] * vec.data_[j];
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
cmpq (%rdi), %rax
jne 0x7fb8
movq 0x10(%rsi), %rcx
cmpq (%rdx), %rcx
jne 0x7fd1
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
testq %rcx, %rcx
movl $0x0, %r9d
cmovgq %rcx, %r9
testq %rax, %rax
cmovleq %r8, %rax
shlq $0x2, %rcx
xorl %r10d, %r10d
cmpq %rax, %r10
je 0x7fb0
andl $0x0, (%rdi,%r10,4)
movq 0x8(%rdx), %r11
movq (%rsi), %rbx
addq %r8, %rbx
xorps %xmm0, %xmm0
xorl %r14d, %r14d
cmpq %r14, %r9
je 0x7fa8
movss (%rbx,%r14,4), %xmm1
mulss (%r11,%r14,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rdi,%r10,4)
incq %r14
jmp 0x7f88
incq %r10
addq %rcx, %r8
jmp 0x7f6e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7a94(%rip), %rdi      # 0xfa53
leaq 0x79b7(%rip), %rsi      # 0xf97d
leaq 0x7a91(%rip), %rcx      # 0xfa5e
pushq $0x5a
jmp 0x7fe8
leaq 0x7ac1(%rip), %rdi      # 0xfa99
leaq 0x799e(%rip), %rsi      # 0xf97d
leaq 0x7a78(%rip), %rcx      # 0xfa5e
pushq $0x5b
popq %rdx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::Model(std::shared_ptr<fasttext::Matrix>, std::shared_ptr<fasttext::Matrix>, std::shared_ptr<fasttext::Args>, int)
Model::Model(std::shared_ptr<Matrix> wi,
             std::shared_ptr<Matrix> wo,
             std::shared_ptr<Args> args,
             int32_t seed)
  : hidden_(args->dim), output_(wo->m_), grad_(args->dim), rng(seed)
{
  wi_ = wi;
  wo_ = wo;
  args_ = args;
  isz_ = wi->m_;
  osz_ = wo->m_;
  hsz_ = args->dim;
  negpos = 0;
  loss_ = 0.0;
  nexamples_ = 1;
  initSigmoid();
  initLog();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rcx), %rax
movslq 0x6c(%rax), %rsi
movq %r15, %rdi
callq 0x7c8c
andq $0x0, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
leaq 0x58(%rbx), %r12
movq (%rbp), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r15, 0x40(%rsp)
callq 0x7c8c
movq %r12, 0x38(%rsp)
leaq 0x68(%rbx), %rdi
movq (%r13), %rax
movslq 0x6c(%rax), %rsi
movq %rdi, 0x30(%rsp)
callq 0x7c8c
leaq 0x10(%rbx), %r15
leaq 0x20(%rbx), %r12
leaq 0xa0(%rbx), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
andq $0x0, 0xb0(%rbx)
leaq 0xc0(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0xd8(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0xf0(%rbx), %rax
movq %rax, 0x10(%rsp)
movslq 0xc(%rsp), %rax
xorl %ecx, %ecx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rsi
cmpq $0x1, %rdx
adcq %rcx, %rdx
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
andq $0x0, 0x100(%rbx)
movq %rdx, 0x108(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98a8
movq %r15, %rdi
movq %rbp, %rsi
callq 0x98a8
movq %r12, %rdi
movq %r13, %rsi
callq 0x617e
movq (%r14), %rax
movl 0x8(%rax), %eax
movl %eax, 0x7c(%rbx)
movq (%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x80(%rbx)
movq (%r13), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x78(%rbx)
andq $0x0, 0xb8(%rbx)
andl $0x0, 0x84(%rbx)
movq $0x1, 0x88(%rbx)
movq %rbx, %rdi
callq 0x829e
movq %rbx, %rdi
callq 0x8314
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x825b
movq %rax, %r14
jmp 0x8265
movq %rax, %r14
jmp 0x8278
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x9988
movq 0x18(%rsp), %rdi
callq 0x9486
movq 0x20(%rsp), %rdi
callq 0x94a8
movq 0x28(%rsp), %rdi
callq 0x626a
movq 0x30(%rsp), %rdi
callq 0x7d50
movq 0x38(%rsp), %rdi
callq 0x7d50
leaq 0x40(%rbx), %rdi
callq 0x626a
movq 0x40(%rsp), %rdi
callq 0x7d50
leaq 0x28(%rbx), %rdi
callq 0x625c
leaq 0x18(%rbx), %rdi
callq 0x625c
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x625c
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::polarization(int, float)
real Model::polarization(int32_t w, real lr) {

  real score = 0.0;
  Vector vec = Vector(hsz_, hidden_labels_);
  score = wo_->dotRow( vec, w);
  score = sigmoid(score);
  real alpha = lr * (1.0 - score);
  grad_.addRow(*wo_, w, alpha);
  wo_->addRow(vec, w, alpha);
  return -log(score);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x78(%rdi), %rsi
leaq 0x40(%rdi), %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x7cb6
movq 0x10(%rbx), %rdi
movslq %ebp, %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x7b34
movq %rbx, %rdi
callq 0x84d6
cvtss2sd 0x10(%rsp), %xmm3
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm1
movsd 0x7032(%rip), %xmm2     # 0xf5e8
subsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm0
leaq 0x68(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r14, %rdx
movss %xmm0, 0x10(%rsp)
callq 0x7e40
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
movss 0x10(%rsp), %xmm0
callq 0x7a98
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss 0x74e9(%rip), %xmm0     # 0xfae8
ja 0x861b
mulss 0x74e3(%rip), %xmm0     # 0xfaec
cvttss2si %xmm0, %eax
movq 0x98(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
xorps 0x72ae(%rip), %xmm1     # 0xf8d0
movaps %xmm1, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7d50
movaps 0x10(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8643
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7d50
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
callq 0x7f32
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x801c
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movslq 0x80(%r14), %rax
cmpq %rax, %r15
jge 0x880f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x801c
movss 0x4(%rsp), %xmm0
maxss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
incq %r15
jmp 0x87e3
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x8887
movq %rbx, %rdi
movq %r15, %rsi
callq 0x801c
movss (%rax), %xmm0
subss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3450
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x801c
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x801c
movss 0x8(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
incq %r15
movl 0x80(%r14), %eax
jmp 0x881b
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x88b6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x801c
movss (%rax), %xmm0
divss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r15
movl 0x80(%r14), %eax
jmp 0x888a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x7d5e
movslq 0x78(%r15), %rcx
cmpq %rcx, %rax
jne 0x8a65
movq %rbx, %rdi
callq 0x7d38
movq (%r14), %r13
movq %r13, %r12
negq %r12
cmpq 0x8(%r14), %r13
je 0x8a19
movq (%r15), %rsi
movslq (%r13), %rdx
movq %rbx, %rdi
callq 0x7da8
addq $0x4, %r13
addq $-0x4, %r12
jmp 0x89fa
addq (%r14), %r12
negq %r12
sarq $0x2, %r12
movq %r12, %xmm0
punpckldq 0x6bd0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6bd8(%rip), %xmm0     # 0xf610
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x6b9c(%rip), %xmm0     # 0xf5e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7d7e
leaq 0x70ac(%rip), %rdi      # 0xfb18
leaq 0x70bb(%rip), %rsi      # 0xfb2e
leaq 0x70c1(%rip), %rcx      # 0xfb3b
pushq $0x7d
popq %rdx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::dfs(int, int, float, std::vector<std::pair<float, int>, std::allocator<std::pair<float, int>>>&, fasttext::Vector&) const
void Model::dfs(int32_t k, int32_t node, real score,
                std::vector<std::pair<real, int32_t>>& heap,
                Vector& hidden) const {
  if (heap.size() == k && score < heap.front().first) {
    return;
  }

  if (tree[node].left == -1 && tree[node].right == -1) {
    heap.push_back(std::make_pair(score, node));
    std::push_heap(heap.begin(), heap.end(), comparePairs);
    if (heap.size() > k) {
      std::pop_heap(heap.begin(), heap.end(), comparePairs);
      heap.pop_back();
    }
    return;
  }

  real f = sigmoid(wo_->dotRow(hidden, node - osz_));
  dfs(k, tree[node].left, score + log(1.0 - f), heap, hidden);
  dfs(k, tree[node].right, score + log(f), heap, hidden);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movss %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jne 0x8b98
movss (%rax), %xmm0
ucomiss 0x8(%rsp), %xmm0
ja 0x8cdc
movslq %edx, %rax
movq 0xf0(%r15), %rcx
movq %rax, %r13
shlq $0x5, %r13
cmpl $-0x1, 0x4(%rcx,%r13)
jne 0x8bbe
addq %r13, %rcx
cmpl $-0x1, 0x8(%rcx)
je 0x8c88
movq 0x10(%r15), %rdi
movslq 0x80(%r15), %rcx
subq %rcx, %rax
movq %r14, %rsi
movq %rax, %rdx
callq 0x7b34
movq %r15, %rdi
callq 0x84d6
movaps %xmm0, %xmm2
movss 0x6efe(%rip), %xmm0     # 0xfae8
movaps %xmm0, %xmm1
movss %xmm2, 0xc(%rsp)
subss %xmm2, %xmm1
ucomiss %xmm0, %xmm1
xorps %xmm0, %xmm0
ja 0x8c19
mulss 0x6ee5(%rip), %xmm1     # 0xfaec
cvttss2si %xmm1, %eax
movq 0x98(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
movq 0xf0(%r15), %rax
movl 0x4(%rax,%r13), %edx
addss 0x8(%rsp), %xmm0
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0x8b54
movq 0xf0(%r15), %rax
movl 0x8(%rax,%r13), %edx
movss 0xc(%rsp), %xmm0
ucomiss 0x6e94(%rip), %xmm0     # 0xfae8
xorps %xmm1, %xmm1
ja 0x8c73
mulss 0x6e8b(%rip), %xmm0     # 0xfaec
cvttss2si %xmm0, %eax
movq 0x98(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movss 0x8(%rsp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x8b76
leaq 0x10(%rsp), %rsi
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rsi)
movl %edx, 0x4(%rsi)
movq %rbx, %rdi
callq 0x9c34
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x22e(%rip), %rdx      # 0x8a82
callq 0x9596
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x8cdc
leaq -0x250(%rip), %rdx      # 0x8a82
callq 0x95b4
addq $-0x8, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::update(std::vector<int, std::allocator<int>> const&, int, float)
void Model::update(const std::vector<int32_t>& input, int32_t target, real lr) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return;
  computeHidden(input, hidden_);

  // update negative sampling for both ns and polar
  if (args_->loss == loss_name::ns || args_->loss == loss_name::polar) {
    loss_ += negativeSampling(target, lr);
  } else if (args_->loss == loss_name::hs) {
    loss_ += hierarchicalSoftmax(target, lr);
  } else {
    loss_ += softmax(target, lr);
  }
  nexamples_ += 1;

  if (args_->model == model_name::sup) {
    grad_.mul(1.0 / input.size());
  }
  for (auto it = input.cbegin(); it != input.cend(); ++it) {
    wi_->addRow(grad_, *it, 1.0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
js 0x8f5f
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x80(%rdi)
jle 0x8f7e
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x8f52
movss %xmm0, 0xc(%rsp)
leaq 0x30(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x89c6
movq 0x20(%r14), %rax
movl 0x88(%rax), %eax
cmpl $0x1, %eax
je 0x8ea1
cmpl $0x4, %eax
movss 0xc(%rsp), %xmm0
je 0x8e95
cmpl $0x2, %eax
jne 0x8eb3
movq %r14, %rdi
movl %ebp, %esi
callq 0x8658
jmp 0x8ebd
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0x870a
jmp 0x8ebd
movq %r14, %rdi
movl %ebp, %esi
callq 0x88ce
addss 0x84(%r14), %xmm0
movss %xmm0, 0x84(%r14)
incq 0x88(%r14)
movq 0x20(%r14), %rax
cmpl $0x3, 0x8c(%rax)
jne 0x8f28
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x6705(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x670d(%rip), %xmm0     # 0xf610
leaq 0x68(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x66cd(%rip), %xmm0     # 0xf5e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x7d7e
movq (%rbx), %r12
leaq 0x68(%r14), %r15
cmpq 0x8(%rbx), %r12
je 0x8f52
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0x6ba1(%rip), %xmm0     # 0xfae8
callq 0x7a98
addq $0x4, %r12
jmp 0x8f2f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6cb5(%rip), %rdi      # 0xfc1b
leaq 0x6bc1(%rip), %rsi      # 0xfb2e
leaq 0x6cb3(%rip), %rcx      # 0xfc27
movl $0xc4, %edx
callq 0x3160
leaq 0x6cec(%rip), %rdi      # 0xfc71
leaq 0x6ba2(%rip), %rsi      # 0xfb2e
leaq 0x6c94(%rip), %rcx      # 0xfc27
movl $0xc5, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x8feb
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x80(%rdi)
jle 0x900a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x855a
addss 0x84(%rbx), %xmm0
movss %xmm0, 0x84(%rbx)
movq (%rbx), %rdi
addq $0x68, %rbx
movl %ebp, %edx
movss 0x6b0b(%rip), %xmm0     # 0xfae8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7a98
leaq 0x6c8d(%rip), %rdi      # 0xfc7f
leaq 0x6b35(%rip), %rsi      # 0xfb2e
leaq 0x6c86(%rip), %rcx      # 0xfc86
movl $0xdd, %edx
callq 0x3160
leaq 0x6cad(%rip), %rdi      # 0xfcbe
leaq 0x6b16(%rip), %rsi      # 0xfb2e
leaq 0x6c67(%rip), %rcx      # 0xfc86
movl $0xde, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rsp, %rdi
callq 0x49f6
movq %rbx, %rdi
callq 0x7d38
movq (%rsp), %r12
movq %r12, %r15
negq %r15
cmpq 0x8(%rsp), %r12
je 0xab30
movq 0x20(%r14), %rsi
movslq (%r12), %rdx
movq %rbx, %rdi
callq 0x7da8
addq $0x4, %r12
addq $-0x4, %r15
jmp 0xab0f
movq (%rsp), %rax
cmpq %rax, %r12
je 0xab7c
addq %r15, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x4ab0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4ab8(%rip), %xmm0     # 0xf610
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x4a7c(%rip), %xmm0     # 0xf5e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0x7d7e
movq %rsp, %rdi
callq 0x626a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xab92
movq %rax, %rbx
movq %rsp, %rdi
callq 0x626a
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0x5089(%rip), %rdx      # 0xfe04
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc9f5
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x34a0
leaq 0x8(%rsp), %rdi
callq 0x34e8
leaq 0x98(%rsp), %rdi
callq 0x3060
testb %al, %al
je 0xae09
movq (%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4292
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x56f4
movq 0x20(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7bce
movq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7bce
leaq 0x28(%rsp), %rdi
callq 0x3360
leaq 0x28(%rsp), %rdi
callq 0x3380
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq 0xd1e0(%rip), %rdi      # 0x17ff0
leaq 0x4ff2(%rip), %rsi      # 0xfe09
callq 0x3240
movq %rax, %rdi
callq 0x3100
pushq $0x1
popq %rdi
callq 0x32a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34e8
jmp 0xae48
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3380
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x33c0
leaq 0x80(%rsp), %rdi
callq 0x3060
testb %al, %al
je 0xaea3
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xaedc
leaq 0x8(%rsp), %rdi
callq 0x3050
leaq 0x8(%rsp), %rdi
callq 0x3070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq 0xd146(%rip), %rdi      # 0x17ff0
leaq 0x4f80(%rip), %rsi      # 0xfe31
callq 0x3240
movq %rax, %rdi
callq 0x3100
pushq $0x1
popq %rdi
callq 0x32a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca2d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcdde
leaq 0x10(%rsp), %rdi
callq 0x625c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xca48
leaq 0x10(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xd00a
leaq 0x10(%rsp), %rdi
callq 0x625c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xca66
leaq 0x20(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xd19c
leaq 0x10(%rsp), %rdi
callq 0x625c
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0xca66
leaq 0x30(%rbx), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xd19c
leaq 0x10(%rsp), %rdi
callq 0x625c
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4384
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x57d8
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x7c18
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x7c18
leaq 0x24(%rsp), %r8
andl $0x0, (%r8)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xca81
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0xd424
leaq 0x10(%rsp), %rdi
callq 0x625c
movq (%rbx), %rax
movq 0x40(%rbx), %rbx
cmpl $0x3, 0x8c(%rax)
jne 0xb01b
movq (%r14), %rsi
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x53d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x902a
jmp 0xb038
movq (%r14), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x53d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x902a
leaq 0x8(%rsp), %rdi
callq 0x757a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb053
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x757a
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::pwv(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::pwv(Model& model, real lr,
                        const std::vector<int32_t>& line) {
  std::uniform_int_distribution<> uniform(1, args_->ws);
  for (int32_t w = 0; w < line.size(); w++) {
    int32_t boundary = uniform(model.rng);
    model.setHiddenLabels( dict_->getLabels(line[w]));
    model.updatePolarization(line[w], lr);
    const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w]);
    for (int32_t c = -boundary; c <= boundary; c++) {
      if (c != 0 && w + c >= 0 && w + c < line.size()) {
        model.update(ngrams, line[w + c], lr);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movss %xmm0, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
movl 0x70(%rax), %eax
leaq 0x18(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, 0x4(%rcx)
leaq 0x108(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x20(%rsp), %r13
movq %rdi, 0x8(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
jbe 0xb4fd
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcaa8
movl %eax, %r15d
movq 0x10(%r12), %rsi
movq (%rbx), %rax
movl (%rax,%rbp,4), %edx
movq %r13, %rdi
callq 0x4848
movq %r14, %rdi
movq %r13, %rsi
callq 0x9466
movq %r13, %rdi
callq 0x626a
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
callq 0x8f9e
movq 0x10(%r12), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x49a2
movq %rax, %r13
movl %r15d, %r12d
negl %r12d
cmpl %r15d, %r12d
jg 0xb4eb
testl %r12d, %r12d
je 0xb4e6
movl %ebp, %eax
addl %r12d, %eax
js 0xb4e6
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0xb4e6
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %r13, %rsi
movss 0x4(%rsp), %xmm0
callq 0x8e2c
incl %r12d
jmp 0xb4ac
incq %rbp
movq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
jmp 0xb433
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x626a
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::textVectors()
void FastText::textVectors() {
  std::vector<int32_t> line, labels;
  Vector vec(args_->dim);
  while (std::cin.peek() != EOF) {
    dict_->getLine(std::cin, line, labels, model_->rng);
    dict_->addNgrams(line, args_->wordNgrams);
    vec.zero();
    for (auto it = line.cbegin(); it != line.cend(); ++it) {
      vec.addRow(*input_, *it);
    }
    if (!line.empty()) {
      vec.mul(1.0 / line.size());
    }
    std::cout << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x40(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x30(%rsp)
movq (%rdi), %rax
movslq 0x6c(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7c8c
movq 0xc373(%rip), %r14      # 0x17fd8
movq %rsp, %r15
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0xbd4e
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %r8
movl $0x108, %eax            # imm = 0x108
addq %rax, %r8
movq %r14, %rsi
movq %r15, %rdx
leaq 0x30(%rsp), %rcx
callq 0x5502
movq (%rbx), %rax
movq 0x10(%rbx), %rdi
movl 0x84(%rax), %edx
movq %r15, %rsi
callq 0x5436
movq %r13, %rdi
callq 0x7d38
movq (%rsp), %r12
movq %r12, %rbp
negq %rbp
cmpq 0x8(%rsp), %r12
je 0xbce6
movq 0x20(%rbx), %rsi
movslq (%r12), %rdx
movq %r13, %rdi
callq 0x7da8
addq $0x4, %r12
addq $-0x4, %rbp
jmp 0xbcc5
movq (%rsp), %rax
cmpq %rax, %r12
je 0xbd32
addq %rbp, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x38fa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3902(%rip), %xmm0     # 0xf610
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x38c6(%rip), %xmm0     # 0xf5e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r13, %rdi
callq 0x7d7e
movq 0xc28f(%rip), %rdi      # 0x17fc8
movq %r13, %rsi
callq 0x8037
movq %rax, %rdi
callq 0x3100
jmp 0xbc6d
leaq 0x20(%rsp), %rdi
callq 0x7d50
leaq 0x30(%rsp), %rdi
callq 0x626a
movq %rsp, %rdi
callq 0x626a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xbd8d
jmp 0xbd80
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7d50
leaq 0x30(%rsp), %rdi
callq 0x626a
movq %rsp, %rdi
callq 0x626a
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0xa0fc(%rip), %rdi      # 0x17fc8
leaq 0x227d(%rip), %rsi      # 0x10150
callq 0x3240
leaq 0x2294(%rip), %rsi      # 0x10173
movq %rax, %rdi
callq 0x3240
leaq 0x22af(%rip), %rsi      # 0x1019d
movq %rax, %rdi
callq 0x3240
leaq 0x22d5(%rip), %rsi      # 0x101d2
movq %rax, %rdi
callq 0x3240
leaq 0x22fe(%rip), %rsi      # 0x1020a
movq %rax, %rdi
callq 0x3240
leaq 0x2321(%rip), %rsi      # 0x1023c
movq %rax, %rdi
callq 0x3240
leaq 0x2357(%rip), %rsi      # 0x10281
movq %rax, %rdi
callq 0x3240
leaq 0x2376(%rip), %rsi      # 0x102af
movq %rax, %rdi
callq 0x3240
leaq 0x2391(%rip), %rsi      # 0x102d9
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
popq %rax
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0xa067(%rip), %rdi      # 0x17fc8
leaq 0x23ac(%rip), %rsi      # 0x10314
callq 0x3240
leaq 0x23d1(%rip), %rsi      # 0x10345
movq %rax, %rdi
callq 0x3240
leaq 0x23e1(%rip), %rsi      # 0x10364
movq %rax, %rdi
callq 0x3240
leaq 0x240d(%rip), %rsi      # 0x1039f
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
popq %rax
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0xa01d(%rip), %rdi      # 0x17fc8
leaq 0x242b(%rip), %rsi      # 0x103dd
callq 0x3240
leaq 0x2387(%rip), %rsi      # 0x10345
movq %rax, %rdi
callq 0x3240
leaq 0x2397(%rip), %rsi      # 0x10364
movq %rax, %rdi
callq 0x3240
leaq 0x23c3(%rip), %rsi      # 0x1039f
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
popq %rax
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x9fd3(%rip), %rdi      # 0x17fc8
leaq 0x241c(%rip), %rsi      # 0x10418
callq 0x3240
leaq 0x233d(%rip), %rsi      # 0x10345
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
popq %rax
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x90, %rsp
cmpl $0x3, %edi
jne 0xe3c1
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x10(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4476
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xae50
leaq 0x10(%rsp), %rdi
callq 0x34e8
leaq 0x30(%rsp), %rdi
callq 0xbda8
xorl %edi, %edi
callq 0x32a0
callq 0xdfed
pushq $0x1
popq %rdi
callq 0x32a0
jmp 0xe3df
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x34e8
jmp 0xe3e2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xe5e6
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/main.cc
// Function: main
int main(int argc, char** argv) {
  if (argc < 2) {
    printUsage();
    exit(EXIT_FAILURE);
  }
  std::string command(argv[1]);
  if (command == "skipgram" || command == "cbow" || command == "supervised" || command == "pwv") {
    train(argc, argv);
  } else if (command == "test") {
    test(argc, argv);
  } else if (command == "print-vectors") {
    printVectors(argc, argv);
  } else if (command == "predict" || command == "predict-prob" ) {
    predict(argc, argv);
  } else {
    printUsage();
    exit(EXIT_FAILURE);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jle 0xe547
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x4476
leaq 0x1f8c(%rip), %rsi      # 0x10469
movq %r14, %rdi
callq 0x44b1
testb %al, %al
jne 0xe528
leaq 0xb69(%rip), %rsi       # 0xf059
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
jne 0xe528
leaq 0xb45(%rip), %rsi       # 0xf04a
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
jne 0xe528
leaq 0xb3b(%rip), %rsi       # 0xf055
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
je 0xe554
movl %ebp, %edi
movq %rbx, %rsi
callq 0xe3f4
leaq 0x10(%rsp), %rdi
callq 0x34e8
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xdec4
pushq $0x1
popq %rdi
callq 0x32a0
leaq 0xb4d(%rip), %rsi       # 0xf0a8
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
je 0xe573
movl %ebp, %edi
movq %rbx, %rsi
callq 0xe019
leaq 0x1ef8(%rip), %rsi      # 0x10472
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
je 0xe592
movl %ebp, %edi
movq %rbx, %rsi
callq 0xe35b
leaq 0x1ee7(%rip), %rsi      # 0x10480
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
jne 0xe5bc
leaq 0x1eae(%rip), %rsi      # 0x1045c
leaq 0x10(%rsp), %rdi
callq 0x44b1
testb %al, %al
je 0xe5c6
movl %ebp, %edi
movq %rbx, %rsi
callq 0xe197
callq 0xdec4
jmp 0xe54c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x34e8
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0xe8, %rsp
leaq 0xdc6(%rip), %rsi       # 0x304e
leaq -0x28(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0x2040
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x23b8
leaq -0x28(%rbp), %rdi
callq 0x2060
callq 0x221c
callq 0x223c
movq 0x2d13(%rip), %rdi      # 0x4fd8
callq 0x225c
movq %rax, %rdi
callq 0x2070
leaq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x244c
leaq -0xe8(%rbp), %rdi
callq 0x2476
leaq -0x88(%rbp), %rdi
callq 0x2476
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
jmp 0x231e
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2060
jmp 0x232d
movq %rax, %rbx
jmp 0x232d
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2476
movq %rbx, %rdi
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
pushq $0x2
popq %rcx
leaq 0x6(%rsp), %r9
movl $0x8000, %edx           # imm = 0x8000
movl %ecx, %r8d
callq 0x3601
testl %eax, %eax
je 0x3798
pushq $-0x1
popq %rax
jmp 0x37c8
movzwl 0x6(%rsp), %r15d
cmpl $0x527, %r15d           # imm = 0x527
jae 0x37d3
movzwl %r14w, %esi
movl %ebp, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rcx
movl %r15d, %r8d
callq 0x36fd
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5953(%rip), %rdi      # 0x912d
callq 0x3310
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: readDNA(int, unsigned int*, unsigned int*)
int readDNA (int i2c_file, uint32_t *svio1, uint32_t *svio2)
{
	uint8_t i;
	int vmin;
	uint8_t dna_buf[64];

	for (i = 0; i < SVIO_NUM_PORTS; i++) {
		// Skip ports referring to the FPGA
		if (0x00 == svio.ports[i].i2c_addr) {
			continue;
		}

		if (i2cDetect(i2c_file, svio.ports[i].i2c_addr) != 0) {
			// Device is not present
			continue;
		}

		// Read the full DNA Header
		if (readMCU(i2c_file, svio.ports[i].i2c_addr, 0x8000, dna_buf,
		            SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (szgParsePortDNA(i, &svio, dna_buf, SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (svio.ports[i].attr & SZG_ATTR_LVDS) {
			switch (svio.ports[i].group) {
				case 0:
					svio.ports[0].ranges[0].min = 250;
					svio.ports[0].ranges[0].max = 250;
					break;
				case 1:
					svio.ports[2].ranges[0].min = 250;
					svio.ports[2].ranges[0].max = 250;
					break;
			}
		}
	}

	// Find a solution
	for (i = 0; i < SVIO_NUM_GROUPS; i++) {
		vmin = szgSolveSmartVIOGroup(svio.ports, svio.group_masks[i]);
		if (vmin > 0) {
			svio.svio_results[i] = vmin;
		}
	}

	*svio1 = svio.svio_results[0];
	*svio2 = svio.svio_results[1];

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movl %edi, %r12d
leaq 0xaa28(%rip), %rbp      # 0xe230
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
pushq $0x28
popq %r14
leaq 0xa9fd(%rip), %r15      # 0xe218
cmpq $0x6, %r13
je 0x38b3
movl (%rbp), %esi
testl %esi, %esi
je 0x38a7
movl %r12d, %edi
callq 0x350c
testl %eax, %eax
jne 0x38a7
movzwl (%rbp), %esi
movl %r12d, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rcx
movl %r14d, %r8d
callq 0x36fd
testl %eax, %eax
jne 0x38fc
movl %r13d, %edi
movq %r15, %rsi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x7b11
testl %eax, %eax
jne 0x38fc
testb $0x1, 0x14(%rbp)
je 0x38a7
movl 0x8(%rbp), %edx
leaq 0xa9d4(%rip), %rax      # 0xe254
leaq 0xa9d1(%rip), %rcx      # 0xe258
testl %edx, %edx
je 0x389e
cmpl $0x1, %edx
jne 0x38a7
leaq 0xaa95(%rip), %rax      # 0xe32c
leaq 0xaa92(%rip), %rcx      # 0xe330
movl $0xfa, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
incq %r13
addq $0x6c, %rbp
jmp 0x381b
pushq $-0x8
popq %r14
leaq 0xa972(%rip), %rbx      # 0xe230
testq %r14, %r14
je 0x38df
movl 0x18(%r14,%r15), %esi
movq %rbx, %rdi
callq 0x7c10
testl %eax, %eax
jle 0x38d9
movl %eax, 0x10(%r14,%r15)
addq $0x4, %r14
jmp 0x38be
movl 0xa93b(%rip), %eax      # 0xe220
movq (%rsp), %rcx
movl %eax, (%rcx)
movl 0xa933(%rip), %eax      # 0xe224
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x38ff
pushq $-0x1
popq %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/include/json.hpp
// Function: void nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
    {
        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        const bool is_negative = (x <= 0) and (x != 0);  // see issue #755
        std::size_t i = 0;

        while (x != 0)
        {
            // spare 1 byte for '\0'
            assert(i < number_buffer.size() - 1);

            const auto digit = std::labs(static_cast<long>(x % 10));
            number_buffer[i++] = static_cast<char>('0' + digit);
            x /= 10;
        }

        if (is_negative)
        {
            // make sure there is capacity for the '-'
            assert(i < number_buffer.size() - 2);
            number_buffer[i++] = '-';
        }

        std::reverse(number_buffer.begin(), number_buffer.begin() + i);
        o->write_characters(number_buffer.data(), i);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5981
leaq 0x10(%rbx), %r14
xorl %r15d, %r15d
pushq $0xa
popq %rcx
movq %rsi, %rax
testq %rax, %rax
je 0x594a
cmpq $0x3f, %r15
je 0x5994
cqto
idivq %rcx
movq %rdx, %rdi
negq %rdi
cmovsq %rdx, %rdi
addb $0x30, %dil
movb %dil, 0x10(%rbx,%r15)
incq %r15
jmp 0x5922
testq %rsi, %rsi
jg 0x595e
cmpq $0x3e, %r15
jae 0x59b3
movb $0x2d, 0x10(%rbx,%r15)
incq %r15
leaq (%r14,%r15), %rsi
movq %r14, %rdi
callq 0x66a2
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq (%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
pushq $0x30
popq %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x2cf1(%rip), %rdi      # 0x868c
leaq 0x28ea(%rip), %rsi      # 0x828c
leaq 0x2d00(%rip), %rcx      # 0x86a9
movl $0x19fd, %edx           # imm = 0x19FD
callq 0x3160
leaq 0x2d7f(%rip), %rdi      # 0x8739
leaq 0x28cb(%rip), %rsi      # 0x828c
leaq 0x2ce1(%rip), %rcx      # 0x86a9
movl $0x1a07, %edx           # imm = 0x1A07
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x4371a(%rip), %r14     # 0x646c0
leaq 0x26070(%rip), %rsi     # 0x4701d
movq %r14, %rdi
callq 0x6770
leaq 0x8(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x1b51c(%rip), %rsi     # 0x3c4e0
movq %r14, %rdi
callq 0x211f7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x212a0
pushq $0x32
popq %rsi
movq %r14, %rdi
callq 0x212ec
leaq 0x8(%rsp), %rdi
callq 0x214b2
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x214b2
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2340
movslq %r15d, %r15
addq $0x10, %rbx
pushq $0x1
popq %r12
cmpq %r15, %r12
jge 0x81c2
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2c3d
incq %r12
addq $0x10, %rbx
jmp 0x81a6
leaq 0x5f07(%rip), %rsi      # 0xe0d0
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2963
movl %eax, %r14d
notl %r14d
shrl $0x1f, %r14d
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq *0x5ebd(%rip)           # 0xe0a8
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>> Vector::operator-<double>(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator-(std::vector<T> vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator-");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::minus<T>());
    return vector1;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
movq (%rdx), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq %rax, %rdi
jne 0x2aec
movq %rcx, %rdi
callq 0x2e02
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x5616(%rip), %rsi      # 0x8114
movq %rax, %rdi
callq 0x22e0
movq 0xa4d3(%rip), %rsi      # 0xcfe0
movq 0xa4ac(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/./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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
movq (%rdx), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq %rax, %rdi
jne 0x2f15
movq %rcx, %rdi
callq 0x2f58
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x5203(%rip), %rsi      # 0x812a
movq %rax, %rdi
callq 0x22e0
movq 0xa0aa(%rip), %rsi      # 0xcfe0
movq 0xa083(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: 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 0x330a
movq %rdx, %rcx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x28
popq %r8
cqto
idivq %r8
decq %rax
pushq $0x3
popq %r8
xorl %edx, %edx
divq %r8
cmpq %rcx, %rax
jbe 0x3326
movl %esi, %eax
leaq (%rcx,%rcx,2), %rsi
addq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x336c
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4e8c(%rip), %rsi      # 0x81a8
movq %rax, %rdi
callq 0x22e0
jmp 0x3340
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4e8c(%rip), %rsi      # 0x81c4
movq %rax, %rdi
callq 0x22e0
movq 0x9c99(%rip), %rsi      # 0xcfe0
movq 0x9c72(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
jmp 0x3358
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22c0
nop