LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::uniform(float)
void Matrix::uniform(real a) {
  std::minstd_rand rng(1);
  std::uniform_real_distribution<> uniform(-a, a);
  for (int64_t i = 0; i < (m_ * n_); i++) {
    data_[i] = uniform(rng);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1d2e0
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq -0x28(%rbp), %rdi
callq 0xf070
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jge 0x1e0bc
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xf170
movq -0x38(%rbp), %rax
cvtsd2ss %xmm0, %xmm0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1e077
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::dotRow(fasttext::Vector const&, long) const
real Matrix::dotRow(const Vector& vec, int64_t i) const {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.size() == n_);
  real d = 0.0;
  for (int64_t j = 0; j < n_; j++) {
    d += at(i, j) * vec.data_[j];
  }
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1e0f5
jmp 0x1e114
leaq 0x2481b(%rip), %rdi     # 0x42917
leaq 0x24bb7(%rip), %rsi     # 0x42cba
movl $0x45, %edx
leaq 0x24bb9(%rip), %rcx     # 0x42cc8
callq 0x52d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x1e124
jmp 0x1e143
leaq 0x24bda(%rip), %rdi     # 0x42d05
leaq 0x24b88(%rip), %rsi     # 0x42cba
movl $0x46, %edx
leaq 0x24b8a(%rip), %rcx     # 0x42cc8
callq 0x52d0
movq -0x10(%rbp), %rdi
callq 0x20c90
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1e158
jmp 0x1e177
leaq 0x24bad(%rip), %rdi     # 0x42d0c
leaq 0x24b54(%rip), %rsi     # 0x42cba
movl $0x47, %edx
leaq 0x24b56(%rip), %rcx     # 0x42cc8
callq 0x52d0
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x1e1db
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1e7f0
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1e187
movss -0x1c(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::addRow(fasttext::Vector const&, long, float)
void Matrix::addRow(const Vector& vec, int64_t i, real a) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.size() == n_);
  for (int64_t j = 0; j < n_; j++) {
    data_[i * n_ + j] += a * vec.data_[j];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1e21a
jmp 0x1e239
leaq 0x246f6(%rip), %rdi     # 0x42917
leaq 0x24a92(%rip), %rsi     # 0x42cba
movl $0x50, %edx
leaq 0x24ae9(%rip), %rcx     # 0x42d1d
callq 0x52d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x1e249
jmp 0x1e268
leaq 0x24ab5(%rip), %rdi     # 0x42d05
leaq 0x24a63(%rip), %rsi     # 0x42cba
movl $0x51, %edx
leaq 0x24aba(%rip), %rcx     # 0x42d1d
callq 0x52d0
movq -0x10(%rbp), %rdi
callq 0x20c90
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1e27d
jmp 0x1e29c
leaq 0x24a88(%rip), %rdi     # 0x42d0c
leaq 0x24a2f(%rip), %rsi     # 0x42cba
movl $0x52, %edx
leaq 0x24a86(%rip), %rcx     # 0x42d1d
callq 0x52d0
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x1e2fc
movq -0x30(%rbp), %rdx
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq (%rdx), %rax
movq -0x18(%rbp), %rcx
imulq 0x10(%rdx), %rcx
addq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1e2a4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::multiplyRow(fasttext::Vector const&, long, long)
void Matrix::multiplyRow(const Vector& nums, int64_t ib, int64_t ie) {
  if (ie == -1) {ie = m_;}
  assert(ie <= nums.size());
  for (auto i = ib; i < ie; i++) {
    real n = nums[i-ib];
    if (n != 0) {
      for (auto j = 0; j < n_; j++) {
        at(i, j) *= n;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x1e343
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jg 0x1e362
jmp 0x1e381
leaq 0x249f1(%rip), %rdi     # 0x42d5a
leaq 0x2494a(%rip), %rsi     # 0x42cba
movl $0x5a, %edx
leaq 0x249f0(%rip), %rcx     # 0x42d6c
callq 0x52d0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1e41f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq -0x18(%rbp), %rsi
callq 0x21410
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1e3c2
jp 0x1e3c2
jmp 0x1e40c
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movslq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x1e40a
movq -0x38(%rbp), %rdi
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x1e820
movss -0x44(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1e3c9
jmp 0x1e40c
jmp 0x1e40e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1e389
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::divideRow(fasttext::Vector const&, long, long)
void Matrix::divideRow(const Vector& denoms, int64_t ib, int64_t ie) {
  if (ie == -1) {ie = m_;}
  assert(ie <= denoms.size());
  for (auto i = ib; i < ie; i++) {
    real n = denoms[i-ib];
    if (n != 0) {
      for (auto j = 0; j < n_; j++) {
        at(i, j) /= n;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x1e463
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jg 0x1e482
jmp 0x1e4a1
leaq 0x24928(%rip), %rdi     # 0x42db1
leaq 0x2482a(%rip), %rsi     # 0x42cba
movl $0x67, %edx
leaq 0x24929(%rip), %rcx     # 0x42dc5
callq 0x52d0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1e543
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq -0x18(%rbp), %rsi
callq 0x21410
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1e4e2
jp 0x1e4e2
jmp 0x1e530
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movslq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x1e52e
movq -0x38(%rbp), %rdi
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x1e820
movss -0x44(%rbp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1e4e9
jmp 0x1e530
jmp 0x1e532
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1e4a9
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::l2NormRow(long) const
real Matrix::l2NormRow(int64_t i) const {
  auto norm = 0.0;
  for (auto j = 0; j < n_; j++) {
    const real v = at(i,j);
    norm += v * v;
  }
  return std::sqrt(norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x1e5c2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1e7f0
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e577
movsd -0x18(%rbp), %xmm0
callq 0x5370
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::load(std::istream&)
void Matrix::load(std::istream& in) {
  in.read((char*) &m_, sizeof(int64_t));
  in.read((char*) &n_, sizeof(int64_t));
  delete[] data_;
  data_ = new real[m_ * n_];
  in.read((char*) data_, m_ * n_ * sizeof(real));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x5540
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
movl $0x8, %edx
callq 0x5540
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1e74a
movq -0x18(%rbp), %rdi
callq 0x5580
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
imulq 0x10(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
imulq 0x10(%rax), %rdx
shlq $0x2, %rdx
callq 0x5540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/shmem_matrix.cc
// Function: fasttext::ShmemMatrix::~ShmemMatrix()
ShmemMatrix::~ShmemMatrix() {
  // Unmap the shared memory segment
  size_t size = m_ * n_ * sizeof(real);
  int ret = munmap((void*)data_, size);
  if (ret == -1) {
    perror("ERROR ShmemMatrix::~ShmemMatrix: munmap failed");
    exit(-1);
  }
  data_ = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
imulq 0x10(%rax), %rcx
shlq $0x2, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5270
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1ea42
leaq 0x244d5(%rip), %rdi     # 0x42f06
callq 0x53a0
jmp 0x1ea38
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movq -0x20(%rbp), %rdi
movq $0x0, (%rdi)
callq 0x1df90
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7f50
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::QMatrix(fasttext::Matrix const&, int, bool)
QMatrix::QMatrix(const Matrix& mat, int32_t dsub, bool qnorm)
      : qnorm_(qnorm), m_(mat.m_), n_(mat.n_),
        codesize_(m_ * std::ceil(n_ / dsub)) {
  codes_ = new uint8_t[codesize_];
  pq_ = std::unique_ptr<ProductQuantizer>( new ProductQuantizer(n_, dsub));
  if (qnorm_) {
    norm_codes_ = new uint8_t[m_];
    npq_ = std::unique_ptr<ProductQuantizer>( new ProductQuantizer(1, 1));
  }
  quantize(mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x20510
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x20510
movq -0x58(%rbp), %rax
movb -0x15(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, -0x50(%rbp)
cvtsi2sdq 0x28(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movq %rax, %rdi
callq 0x20540
movsd %xmm0, -0x40(%rbp)
jmp 0x1fc19
movq -0x68(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movl %edx, (%rcx)
movslq 0x38(%rax), %rdi
callq 0x5030
movq %rax, -0x70(%rbp)
jmp 0x1fc44
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x50, %edi
callq 0x5430
movq %rax, -0x78(%rbp)
jmp 0x1fc60
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rax
movl 0x30(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x1bf40
jmp 0x1fc75
movq -0x78(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x20560
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20590
leaq -0x30(%rbp), %rdi
callq 0x205c0
movq -0x68(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x1fd62
movq -0x68(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5030
movq %rax, -0x80(%rbp)
jmp 0x1fcb9
movq -0x68(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x50, %edi
callq 0x5430
movq %rax, -0x88(%rbp)
jmp 0x1fcd8
movq -0x88(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1bf40
jmp 0x1fced
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x20560
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x20590
leaq -0x38(%rbp), %rdi
callq 0x205c0
jmp 0x1fd62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1fd7a
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x5440
jmp 0x1fd7a
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x5440
jmp 0x1fd7a
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fda0
jmp 0x1fd71
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x205c0
movq -0x58(%rbp), %rdi
callq 0x205c0
movq -0x20(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::quantize(fasttext::Matrix const&)
void QMatrix::quantize(const Matrix& matrix) {
  assert(n_ == matrix.n_);
  assert(m_ == matrix.m_);
  Matrix temp(matrix);
  if (qnorm_) {
    Vector norms(temp.m_);
    temp.l2NormRow(norms);
    temp.divideRow(norms);
    quantizeNorm(norms);
  }
  auto dataptr = temp.data_;
  pq_->train(m_, dataptr);
  pq_->compute_codes(dataptr, codes_, m_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1fdc8
jmp 0x1fde7
leaq 0x233a3(%rip), %rdi     # 0x43172
leaq 0x23349(%rip), %rsi     # 0x4311f
movl $0x2f, %edx
leaq 0x233a0(%rip), %rcx     # 0x43182
callq 0x52d0
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1fdfb
jmp 0x1fe1a
leaq 0x233b1(%rip), %rdi     # 0x431b3
leaq 0x23316(%rip), %rsi     # 0x4311f
movl $0x30, %edx
leaq 0x2336d(%rip), %rcx     # 0x43182
callq 0x52d0
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1de70
movq -0x58(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x1fea8
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x20c00
jmp 0x1fe40
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1e5e0
jmp 0x1fe4f
xorl %eax, %eax
movl %eax, %edx
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq $-0x1, %rcx
callq 0x1e430
jmp 0x1fe69
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1ffa0
jmp 0x1fe78
leaq -0x38(%rbp), %rdi
callq 0x20c60
jmp 0x1fea8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1feff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20c60
jmp 0x1feff
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x20610
movq %rax, %rdi
movq -0x58(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x50(%rbp), %rdx
callq 0x1ca40
jmp 0x1fece
movq -0x58(%rbp), %rdi
callq 0x20610
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq 0x10(%rax), %rdx
movl 0x28(%rax), %ecx
callq 0x1d040
jmp 0x1fef0
leaq -0x28(%rbp), %rdi
callq 0x1df90
addq $0x60, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x1df90
movq -0x40(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::quantizeNorm(fasttext::Vector const&)
void QMatrix::quantizeNorm(const Vector& norms) {
  assert(qnorm_);
  assert(norms.m_ == m_);
  auto dataptr = norms.data_;
  npq_->train(m_, dataptr);
  npq_->compute_codes(dataptr, norm_codes_, m_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x20(%rax)
je 0x1ffc0
jmp 0x1ffdf
leaq 0x23151(%rip), %rdi     # 0x43118
leaq 0x23151(%rip), %rsi     # 0x4311f
movl $0x27, %edx
leaq 0x23154(%rip), %rcx     # 0x4312e
callq 0x52d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x28(%rcx), %rax
jne 0x1fff2
jmp 0x20011
leaq 0x2316a(%rip), %rdi     # 0x43163
leaq 0x2311f(%rip), %rsi     # 0x4311f
movl $0x28, %edx
leaq 0x23122(%rip), %rcx     # 0x4312e
callq 0x52d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x1ca40
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdx
movq 0x28(%rax), %rax
movl %eax, %ecx
callq 0x1d040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::addToVector(fasttext::Vector&, int) const
void QMatrix::addToVector(Vector& x, int32_t t) const {
  real norm = 1;
  if (qnorm_) {
    norm = npq_->get_centroids(0, norm_codes_[t])[0];
  }
  pq_->addcode(x, codes_, t, norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x22835(%rip), %xmm0    # 0x428c8
movss %xmm0, -0x18(%rbp)
testb $0x1, 0x20(%rax)
je 0x200ce
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
xorl %esi, %esi
movzbl (%rax,%rcx), %edx
callq 0x1c110
movss (%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20610
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rdx
movl -0x14(%rbp), %ecx
movss -0x18(%rbp), %xmm0
callq 0x1ce80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::dotRow(fasttext::Vector const&, long) const
real QMatrix::dotRow(const Vector& vec, int64_t i) const {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.size() == n_);
  real norm = 1;
  if (qnorm_) {
    norm = npq_->get_centroids(0, norm_codes_[i])[0];
  }
  return pq_->mulcode(vec, codes_, i, norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x20125
jmp 0x20144
leaq 0x227eb(%rip), %rdi     # 0x42917
leaq 0x22fec(%rip), %rsi     # 0x4311f
movl $0x46, %edx
leaq 0x23084(%rip), %rcx     # 0x431c3
callq 0x52d0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jge 0x20154
jmp 0x20173
leaq 0x22baa(%rip), %rdi     # 0x42d05
leaq 0x22fbd(%rip), %rsi     # 0x4311f
movl $0x47, %edx
leaq 0x23055(%rip), %rcx     # 0x431c3
callq 0x52d0
movq -0x10(%rbp), %rdi
callq 0x20c90
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x20188
jmp 0x201a7
leaq 0x22b7d(%rip), %rdi     # 0x42d0c
leaq 0x22f89(%rip), %rsi     # 0x4311f
movl $0x48, %edx
leaq 0x23021(%rip), %rcx     # 0x431c3
callq 0x52d0
movq -0x28(%rbp), %rax
movss 0x22715(%rip), %xmm0    # 0x428c8
movss %xmm0, -0x1c(%rbp)
testb $0x1, 0x20(%rax)
je 0x201ee
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
xorl %esi, %esi
movzbl (%rax,%rcx), %edx
callq 0x1c110
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20610
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movss -0x1c(%rbp), %xmm0
callq 0x1cd70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::save(std::ostream&)
void QMatrix::save(std::ostream& out) {
    out.write((char*) &qnorm_, sizeof(qnorm_));
    out.write((char*) &m_, sizeof(m_));
    out.write((char*) &n_, sizeof(n_));
    out.write((char*) &codesize_, sizeof(codesize_));
    out.write((char*) codes_, codesize_ * sizeof(uint8_t));
    pq_->save(out);
    if (qnorm_) {
      out.write((char*) norm_codes_, m_ * sizeof(uint8_t));
      npq_->save(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
movl $0x1, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
movl $0x8, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
movl $0x8, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
movslq 0x38(%rax), %rdx
shlq $0x0, %rdx
callq 0x55b0
movq -0x18(%rbp), %rdi
callq 0x20610
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0b0
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x20336
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdx
shlq $0x0, %rdx
callq 0x55b0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/qmatrix.cc
// Function: fasttext::QMatrix::load(std::istream&)
void QMatrix::load(std::istream& in) {
    in.read((char*) &qnorm_, sizeof(qnorm_));
    in.read((char*) &m_, sizeof(m_));
    in.read((char*) &n_, sizeof(n_));
    in.read((char*) &codesize_, sizeof(codesize_));
    codes_ = new uint8_t[codesize_];
    in.read((char*) codes_, codesize_ * sizeof(uint8_t));
    pq_ = std::unique_ptr<ProductQuantizer>( new ProductQuantizer());
    pq_->load(in);
    if (qnorm_) {
      norm_codes_ = new uint8_t[m_];
      in.read((char*) norm_codes_, m_ * sizeof(uint8_t));
      npq_ = std::unique_ptr<ProductQuantizer>( new ProductQuantizer());
      npq_->load(in);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
movl $0x1, %edx
callq 0x5540
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
movl $0x8, %edx
movq %rdx, -0x48(%rbp)
callq 0x5540
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x5540
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x40(%rbp), %rax
movslq 0x38(%rax), %rdi
callq 0x5030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
movslq 0x38(%rax), %rdx
callq 0x5540
movl $0x50, %edi
callq 0x5430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x20630
jmp 0x203f3
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x20560
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x20590
leaq -0x18(%rbp), %rdi
callq 0x205c0
movq -0x40(%rbp), %rdi
callq 0x20610
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1d160
movq -0x40(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x204f7
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x5540
movl $0x50, %edi
callq 0x5430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x20630
jmp 0x2047d
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x20560
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x20590
leaq -0x30(%rbp), %rdi
callq 0x205c0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x20610
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1d160
jmp 0x204f7
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x5440
jmp 0x204fd
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x5440
jmp 0x204fd
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/vector.cc
// Function: fasttext::Vector::norm() const
real Vector::norm() const {
  real sum = 0;
  for (int64_t i = 0; i < m_; i++) {
    sum += data_[i] * data_[i];
  }
  return std::sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jge 0x20d6f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0xc(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20d24
movss -0xc(%rbp), %xmm0
callq 0x214d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: epfml[P]Bi-Sent2Vec/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long)
void Vector::addRow(const Matrix& A, int64_t i) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += A.at(i, j);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x20f55
jmp 0x20f74
leaq 0x219bb(%rip), %rdi     # 0x42917
leaq 0x222ae(%rip), %rsi     # 0x43211
movl $0x46, %edx
leaq 0x22318(%rip), %rcx     # 0x43287
callq 0x52d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x20f84
jmp 0x20fa3
leaq 0x22333(%rip), %rdi     # 0x432be
leaq 0x2227f(%rip), %rsi     # 0x43211
movl $0x47, %edx
leaq 0x222e9(%rip), %rcx     # 0x43287
callq 0x52d0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x20fb6
jmp 0x20fd5
leaq 0x2230a(%rip), %rdi     # 0x432c7
leaq 0x2224d(%rip), %rsi     # 0x43211
movl $0x48, %edx
leaq 0x222b7(%rip), %rcx     # 0x43287
callq 0x52d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x21027
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1e7f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movss (%rcx), %xmm0
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x20fdd
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/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.at(i, j);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x2105a
jmp 0x21079
leaq 0x218b6(%rip), %rdi     # 0x42917
leaq 0x221a9(%rip), %rsi     # 0x43211
movl $0x4f, %edx
leaq 0x2225e(%rip), %rcx     # 0x432d2
callq 0x52d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x21089
jmp 0x210a8
leaq 0x2222e(%rip), %rdi     # 0x432be
leaq 0x2217a(%rip), %rsi     # 0x43211
movl $0x50, %edx
leaq 0x2222f(%rip), %rcx     # 0x432d2
callq 0x52d0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x210bb
jmp 0x210da
leaq 0x22205(%rip), %rdi     # 0x432c7
leaq 0x22148(%rip), %rsi     # 0x43211
movl $0x51, %edx
leaq 0x221fd(%rip), %rcx     # 0x432d2
callq 0x52d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x21143
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1e7f0
movss -0x34(%rbp), %xmm0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movss (%rcx), %xmm2
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x210e2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/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] = A.dotRow(vec, i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq (%rcx), %rax
jne 0x211db
jmp 0x211fa
leaq 0x22165(%rip), %rdi     # 0x43347
leaq 0x22028(%rip), %rsi     # 0x43211
movl $0x5d, %edx
leaq 0x2215d(%rip), %rcx     # 0x43352
callq 0x52d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2120d
jmp 0x2122c
leaq 0x22179(%rip), %rdi     # 0x4338d
leaq 0x21ff6(%rip), %rsi     # 0x43211
movl $0x5e, %edx
leaq 0x2212b(%rip), %rcx     # 0x43352
callq 0x52d0
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jge 0x21271
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1e0d0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21234
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/vector.cc
// Function: fasttext::Vector::mul(fasttext::QMatrix const&, fasttext::Vector const&)
void Vector::mul(const QMatrix& A, const Vector& vec) {
  assert(A.getM() == m_);
  assert(A.getN() == vec.m_);
  for (int64_t i = 0; i < m_; i++) {
    data_[i] = A.dotRow(vec, i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20220
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x212b0
jmp 0x212cf
leaq 0x220e5(%rip), %rdi     # 0x4339c
leaq 0x21f53(%rip), %rsi     # 0x43211
movl $0x65, %edx
leaq 0x220e1(%rip), %rcx     # 0x433ab
callq 0x52d0
movq -0x10(%rbp), %rdi
callq 0x20240
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x212e3
jmp 0x21302
leaq 0x220fd(%rip), %rdi     # 0x433e7
leaq 0x21f20(%rip), %rsi     # 0x43211
movl $0x66, %edx
leaq 0x220ae(%rip), %rcx     # 0x433ab
callq 0x52d0
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jge 0x21347
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x20100
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2130a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/vector.cc
// Function: fasttext::Vector::argmax()
int64_t Vector::argmax() {
  real max = data_[0];
  int64_t argmax = 0;
  for (int64_t i = 1; i < m_; i++) {
    if (data_[i] > max) {
      max = data_[i];
      argmax = i;
    }
  }
  return argmax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rax
movss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jge 0x213cf
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x213bf
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x213c1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2137d
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/vector.cc
// Function: fasttext::operator<<(std::ostream&, fasttext::Vector const&)
std::ostream& operator<<(std::ostream& os, const Vector& v)
{
  os << std::setprecision(5);
  for (int64_t j = 0; j < v.m_; j++) {
    os << v.data_[j] << ' ';
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x5, %edi
callq 0x214f0
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x56a0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x214bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
callq 0x5330
movq %rax, %rdi
movl $0x20, %esi
callq 0x54d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21479
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::initSigmoid()
void Model::initSigmoid() {
  t_sigmoid = new real[SIGMOID_TABLE_SIZE + 1];
  for (int i = 0; i < SIGMOID_TABLE_SIZE + 1; i++) {
    real x = real(i * 2 * MAX_SIGMOID) / SIGMOID_TABLE_SIZE - MAX_SIGMOID;
    t_sigmoid[i] = 1.0 / (1.0 + std::exp(-x));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x804, %edi            # imm = 0x804
callq 0x5030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x98(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x201, -0xc(%rbp)      # imm = 0x201
jge 0x218b2
movl -0xc(%rbp), %eax
shll %eax
shll $0x3, %eax
cvtsi2ss %eax, %xmm0
movss 0x21bd8(%rip), %xmm1    # 0x4341c
divss %xmm1, %xmm0
movss 0x21bc8(%rip), %xmm1    # 0x43418
subss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
callq 0x24010
movq -0x18(%rbp), %rax
cvtss2sd %xmm0, %xmm0
movsd 0x21038(%rip), %xmm1    # 0x428b8
addsd %xmm0, %xmm1
movsd 0x2102c(%rip), %xmm0    # 0x428b8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x98(%rax), %rax
movslq -0xc(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21823
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::initLog()
void Model::initLog() {
  t_log = new real[LOG_TABLE_SIZE + 1];
  for (int i = 0; i < LOG_TABLE_SIZE + 1; i++) {
    real x = (real(i) + 1e-5) / LOG_TABLE_SIZE;
    t_log[i] = std::log(x);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x804, %edi            # imm = 0x804
callq 0x5030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x201, -0xc(%rbp)      # imm = 0x201
jge 0x2194f
cvtsi2ssl -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x21afb(%rip), %xmm1    # 0x43408
addsd %xmm1, %xmm0
movsd 0x21ae7(%rip), %xmm1    # 0x43400
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
callq 0x24030
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0xc(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x218f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::setQuantizePointer(std::shared_ptr<fasttext::QMatrix>, std::shared_ptr<fasttext::QMatrix>, bool)
void Model::setQuantizePointer(std::shared_ptr<QMatrix> qwi,
                               std::shared_ptr<QMatrix> qwo, bool qout) {
  qwi_ = qwi;
  qwo_ = qwo;
  if (qout) {
    osz_ = qwo_->getM();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x23830
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x30, %rdi
callq 0x23830
testb $0x1, -0x19(%rbp)
je 0x21ac9
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x23860
movq %rax, %rdi
callq 0x20220
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, 0x88(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::binaryLogistic(int, bool, float)
real Model::binaryLogistic(int32_t target, bool label, real lr) {
  real score = sigmoid(wo_->dotRow(hidden_, target));
  real alpha = lr * (real(label) - score);
  grad_.addRow(*wo_, target, alpha);
  wo_->addRow(hidden_, target, alpha);
  if (label) {
    return -log(score);
  } else {
    return -log(1.0 - score);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x235f0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x50, %rsi
movslq -0x14(%rbp), %rdx
callq 0x1e0d0
movq -0x30(%rbp), %rdi
callq 0x21c00
movq -0x30(%rbp), %rdi
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2ss %eax, %xmm1
subss -0x20(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movq %rdi, %rax
addq $0x70, %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rdi
callq 0x23880
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
movss -0x24(%rbp), %xmm0
callq 0x21030
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x235f0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x50, %rsi
movslq -0x14(%rbp), %rdx
movss -0x24(%rbp), %xmm0
callq 0x1e1f0
testb $0x1, -0x15(%rbp)
je 0x21bb8
movq -0x30(%rbp), %rdi
movss -0x20(%rbp), %xmm0
callq 0x21cb0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x21bec
movq -0x30(%rbp), %rdi
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x20ceb(%rip), %xmm0    # 0x428b8
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x21cb0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::sigmoid(float) const
real Model::sigmoid(real x) const {
  if (x < -MAX_SIGMOID) {
    return 0.0;
  } else if (x > MAX_SIGMOID) {
    return 1.0;
  } else {
    int i = int((x + MAX_SIGMOID) * SIGMOID_TABLE_SIZE / MAX_SIGMOID / 2);
    return t_sigmoid[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x21803(%rip), %xmm0    # 0x43420
ucomiss -0x14(%rbp), %xmm0
jbe 0x21c2d
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x21c9f
movss -0x14(%rbp), %xmm0
movss 0x217de(%rip), %xmm1    # 0x43418
ucomiss %xmm1, %xmm0
jbe 0x21c4e
movss 0x20c81(%rip), %xmm0    # 0x428c8
movss %xmm0, -0x4(%rbp)
jmp 0x21c9f
movq -0x20(%rbp), %rax
movss 0x217be(%rip), %xmm0    # 0x43418
addss -0x14(%rbp), %xmm0
movss 0x217b5(%rip), %xmm1    # 0x4341c
mulss %xmm1, %xmm0
movss 0x217a5(%rip), %xmm1    # 0x43418
divss %xmm1, %xmm0
movss 0x20c4d(%rip), %xmm1    # 0x428cc
divss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x18(%rbp)
movq 0x98(%rax), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::log(float) const
real Model::log(real x) const {
  if (x > 1.0) {
    return 0.0;
  }
  int i = int(x * LOG_TABLE_SIZE);
  return t_log[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x20be2(%rip), %xmm1    # 0x428b8
ucomisd %xmm1, %xmm0
jbe 0x21ce6
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x21d13
movq -0x20(%rbp), %rax
movss 0x2172a(%rip), %xmm0    # 0x4341c
mulss -0x14(%rbp), %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x18(%rbp)
movq 0xa0(%rax), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::negativeSampling(int, float)
real Model::negativeSampling(int32_t target, real lr) {
  real loss = 0.0;
  grad_.zero();
  for (int32_t n = 0; n <= args_->neg; n++) {
    if (n == 0) {
      loss += binaryLogistic(target, true, lr);
    } else {
      loss += binaryLogistic(getNegative(target), false, lr);
    }
  }
  return loss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
addq $0x70, %rdi
callq 0x20cb0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x40, %rdi
callq 0xe6e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jg 0x21dd2
cmpl $0x0, -0x18(%rbp)
jne 0x21d9d
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
movl $0x1, %edx
callq 0x21ad0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x21dc5
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21de0
movq -0x20(%rbp), %rdi
movl %eax, %esi
movss -0x10(%rbp), %xmm0
xorl %edx, %edx
callq 0x21ad0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x21dc7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x21d54
movss -0x14(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::getNegative(int)
int32_t Model::getNegative(int32_t target) {
  int32_t negative;
  do {
    negative = negatives[negpos];
    negpos = (negpos + 1) % negatives.size();
  } while (target == negative);
  return negative;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0xa8, %rdi
movq 0xc0(%rax), %rsi
callq 0xe240
movq -0x18(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq 0xc0(%rdi), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
addq $0xa8, %rdi
callq 0xed50
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq -0x18(%rbp), %rax
movq %rdx, 0xc0(%rax)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x21df7
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::hierarchicalSoftmax(int, float)
real Model::hierarchicalSoftmax(int32_t target, real lr) {
  real loss = 0.0;
  grad_.zero();
  const std::vector<bool>& binaryCode = codes[target];
  const std::vector<int32_t>& pathToRoot = paths[target];
  for (int32_t i = 0; i < pathToRoot.size(); i++) {
    loss += binaryLogistic(pathToRoot[i], binaryCode[i], lr);
  }
  return loss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
addq $0x70, %rdi
callq 0x20cb0
movq -0x38(%rbp), %rdi
addq $0xe0, %rdi
movslq -0xc(%rbp), %rsi
callq 0x238b0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xc8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x238d0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0xed50
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x21f2c
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xe1d0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x238f0
movq -0x38(%rbp), %rdi
movl -0x44(%rbp), %esi
movss -0x10(%rbp), %xmm0
movzbl %al, %edx
andl $0x1, %edx
callq 0x21ad0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21ec4
movss -0x14(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::computeOutputSoftmax(fasttext::Vector&, fasttext::Vector&) const
void Model::computeOutputSoftmax(Vector& hidden, Vector& output) const {
  if (quant_ && args_->qout) {
    output.mul(*qwo_, hidden);
  } else {
    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), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x118(%rax)
je 0x21fa2
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0xe6e0
testb $0x1, 0x12c(%rax)
je 0x21fa2
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0x23940
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x21280
jmp 0x21fc7
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x23880
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x211b0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x213e0
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x88(%rcx), %eax
jge 0x22028
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x213e0
movq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x23970
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21fec
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x88(%rcx), %eax
jge 0x220a2
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x213e0
movss (%rax), %xmm0
subss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x57e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x213e0
movss -0x4c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x213e0
movss (%rax), %xmm0
addss -0x20(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2202f
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x88(%rcx), %eax
jge 0x220eb
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x213e0
movss -0x50(%rbp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x220a9
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)