LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
js 0xbfcc
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rdx, 0x8(%rdi)
jle 0xbfe5
movq %rsi, %r14
movq %rsi, %rdi
callq 0xd074
cmpq 0x10(%r15), %rax
jne 0xbffe
imulq %rax, %rbx
shlq $0x2, %rbx
addq (%r15), %rbx
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
xorps %xmm0, %xmm0
cmpq %rdx, %rax
je 0xbfc6
movss (%rbx,%rdx,4), %xmm1
mulss (%rcx,%rdx,4), %xmm1
addss %xmm1, %xmm0
incq %rdx
jmp 0xbfae
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe96c(%rip), %rdi      # 0x1a93f
leaq 0xed3a(%rip), %rsi      # 0x1ad14
leaq 0xed41(%rip), %rcx      # 0x1ad22
pushq $0x45
jmp 0xc015
leaq 0xed73(%rip), %rdi      # 0x1ad5f
leaq 0xed21(%rip), %rsi      # 0x1ad14
leaq 0xed28(%rip), %rcx      # 0x1ad22
pushq $0x46
jmp 0xc015
leaq 0xed61(%rip), %rdi      # 0x1ad66
leaq 0xed08(%rip), %rsi      # 0x1ad14
leaq 0xed0f(%rip), %rcx      # 0x1ad22
pushq $0x47
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdx, %rdx
js 0xc092
movq %rdx, %rbx
movq %rdi, %r14
movss %xmm0, 0xc(%rsp)
cmpq %rdx, 0x8(%rdi)
jle 0xc0ab
movq %rsi, %r15
movq %rsi, %rdi
callq 0xd074
cmpq 0x10(%r14), %rax
jne 0xc0c4
movq 0x8(%r15), %rcx
imulq %rax, %rbx
shlq $0x2, %rbx
addq (%r14), %rbx
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
movss 0xc(%rsp), %xmm1
cmpq %rdx, %rax
je 0xc088
movss (%rcx,%rdx,4), %xmm0
mulss %xmm1, %xmm0
addss (%rbx,%rdx,4), %xmm0
movss %xmm0, (%rbx,%rdx,4)
incq %rdx
jmp 0xc06b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe8a6(%rip), %rdi      # 0x1a93f
leaq 0xec74(%rip), %rsi      # 0x1ad14
leaq 0xecd0(%rip), %rcx      # 0x1ad77
pushq $0x50
jmp 0xc0db
leaq 0xecad(%rip), %rdi      # 0x1ad5f
leaq 0xec5b(%rip), %rsi      # 0x1ad14
leaq 0xecb7(%rip), %rcx      # 0x1ad77
pushq $0x51
jmp 0xc0db
leaq 0xec9b(%rip), %rdi      # 0x1ad66
leaq 0xec42(%rip), %rsi      # 0x1ad14
leaq 0xec9e(%rip), %rcx      # 0x1ad77
pushq $0x52
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpq $-0x1, %rcx
jne 0xc104
movq 0x8(%r12), %r14
movq %r15, %rdi
callq 0xd074
cmpq %rax, %r14
jg 0xc189
leaq (,%rbx,4), %r13
movq %rbx, %rbp
cmpq %r14, %rbp
jge 0xc17a
movq %rbp, %rsi
subq %rbx, %rsi
movq %r15, %rdi
callq 0xd460
movss (%rax), %xmm0
ucomiss 0xebd6(%rip), %xmm0     # 0x1ad10
jne 0xc13e
jnp 0xc171
movq 0x10(%r12), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
imulq %r13, %rax
addq (%r12), %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xc171
movss (%rax,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
jmp 0xc159
incq %rbp
addq $0x4, %r13
jmp 0xc11c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xec24(%rip), %rdi      # 0x1adb4
leaq 0xeb7d(%rip), %rsi      # 0x1ad14
leaq 0xec28(%rip), %rcx      # 0x1adc6
pushq $0x5a
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpq $-0x1, %rcx
jne 0xc1c8
movq 0x8(%r12), %r14
movq %r15, %rdi
callq 0xd074
cmpq %rax, %r14
jg 0xc24d
leaq (,%rbx,4), %r13
movq %rbx, %rbp
cmpq %r14, %rbp
jge 0xc23e
movq %rbp, %rsi
subq %rbx, %rsi
movq %r15, %rdi
callq 0xd460
movss (%rax), %xmm0
ucomiss 0xeb12(%rip), %xmm0     # 0x1ad10
jne 0xc202
jnp 0xc235
movq 0x10(%r12), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
imulq %r13, %rax
addq (%r12), %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xc235
movss (%rax,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
jmp 0xc21d
incq %rbp
addq $0x4, %r13
jmp 0xc1e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xebb7(%rip), %rdi      # 0x1ae0b
leaq 0xeab9(%rip), %rsi      # 0x1ad14
leaq 0xebbd(%rip), %rcx      # 0x1ae1f
pushq $0x67
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x10(%rdi), %rax
imulq %rax, %rsi
shlq $0x2, %rsi
addq (%rdi), %rsi
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0xc2a2
movss (%rsi,%rcx,4), %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0xc287
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc2b2
sqrtsd %xmm0, %xmm0
jmp 0xc2b7
callq 0x42a0
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
pushq $0x8
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc3be
callq 0x4410
movq 0x10(%r14), %r15
imulq 0x8(%r14), %r15
movq %r15, %rax
shrq $0x3e, %rax
shlq $0x2, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x4030
movq %rax, (%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/shmem_matrix.cc
// Function: fasttext::ShmemMatrix::ShmemMatrix(char const*, long, long, int)
ShmemMatrix::ShmemMatrix(const char* name, const int64_t m, const int64_t n, const int timeout_sec) {
  m_ = m;
  n_ = n;

  // Open an existing shared memory segment (keep retrying until timeout expires)
  int fd = -1;
  int waited_sec = 0;
  while (true) {
    fd = shm_open(name, O_RDONLY, 0444);
    if (fd != -1) break;
    if (errno == ENOENT) {
      if (timeout_sec != -1 && waited_sec >= timeout_sec) {
        fprintf(stderr, "ERROR ShmemMatrix::ShmemMatrix: timeout expired\n");
        exit(-1);
      } else {
        sleep(1);
        waited_sec += 1;
      }
    } else {
      perror("ERROR ShmemMatrix::ShmemMatrix: shm_open failed");
      exit(-1);
    }
  }

  // Map the shared memory segment
  size_t size = m_ * n_ * sizeof(real);
  void* ptr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
  if (ptr == (void*)-1) {
    perror("ERROR ShmemMatrix::ShmemMatrix: mmap failed");
    exit(-1);
  } else {
    data_ = (real*)ptr;
  }

  // Close the file descriptor
  int ret = close(fd);
  if (ret == -1) {
    perror("ERROR ShmemMatrix::ShmemMatrix: close failed");
    exit(-1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbde0
movq %r12, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %r13d, %r13d
pushq $0x1
popq %r15
movq %r14, %rdi
xorl %esi, %esi
movl $0x124, %edx            # imm = 0x124
callq 0x4580
movl %eax, %r12d
cmpl $-0x1, %eax
jne 0xc464
callq 0x4060
cmpl $0x2, (%rax)
jne 0xc4a8
cmpl $-0x1, %ebp
sete %al
cmpl %ebp, %r13d
setl %cl
orb %al, %cl
je 0xc4b6
movl %r15d, %edi
callq 0x4280
incl %r13d
jmp 0xc426
movq 0x8(%rbx), %rsi
imulq 0x10(%rbx), %rsi
shlq $0x2, %rsi
pushq $0x1
popq %rcx
xorl %edi, %edi
movl %ecx, %edx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x45e0
cmpq $-0x1, %rax
je 0xc4da
movq %rax, (%rbx)
movl %r12d, %edi
callq 0x4680
cmpl $-0x1, %eax
je 0xc4e3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xea28(%rip), %rdi      # 0x1aed7
callq 0x42c0
jmp 0xc4d2
movq 0x1bb0b(%rip), %rax     # 0x27fc8
movq (%rax), %rcx
leaq 0xe9df(%rip), %rdi      # 0x1aea6
pushq $0x30
popq %rsi
pushq $0x1
popq %rdx
callq 0x4660
pushq $-0x1
popq %rdi
callq 0x43b0
leaq 0xea26(%rip), %rdi      # 0x1af07
jmp 0xc4af
leaq 0xea49(%rip), %rdi      # 0x1af33
jmp 0xc4af
jmp 0xc4ee
movq %rax, %r14
movq %rbx, %rdi
callq 0xbed2
movq %r14, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
imulq 0x10(%rbx), %rsi
shlq $0x2, %rsi
callq 0x41f0
cmpl $-0x1, %eax
je 0xc52d
andq $0x0, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xbed2
leaq 0xea2c(%rip), %rdi      # 0x1af60
callq 0x42c0
pushq $-0x1
popq %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb %cl, 0x20(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x10(%rsi), %r12
movq %r12, 0x30(%rdi)
cvtsi2sd %rax, %xmm0
movslq %edx, %rcx
movq %r12, %rax
cqto
idivq %rcx
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x38(%rdi)
movslq %eax, %rdi
callq 0x4030
movq %rax, 0x10(%rbx)
pushq $0x50
popq %rdi
callq 0x4340
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xaf68
movq %rsp, %r12
andq $0x0, (%r12)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd008
movq %r12, %rdi
callq 0xcfba
cmpb $0x1, 0x20(%rbx)
jne 0xcadd
movq 0x28(%rbx), %rdi
callq 0x4030
movq %rax, 0x18(%rbx)
pushq $0x50
popq %rdi
callq 0x4340
movq %rax, %r12
pushq $0x1
popq %rdx
movq %rax, %rdi
movl %edx, %esi
callq 0xaf68
movq %rsp, %r13
andq $0x0, (%r13)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd008
movq %r13, %rdi
callq 0xcfba
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcb32
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x50
popq %rsi
movq %r12, %rdi
jmp 0xcb0d
jmp 0xcb16
movq %rax, %r15
pushq $0x50
popq %rsi
movq %r13, %rdi
callq 0x4350
jmp 0xcb19
jmp 0xcb16
movq %rax, %r15
movq %r14, %rdi
callq 0xcfba
movq %rbx, %rdi
callq 0xcfba
movq %r15, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0x30(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xcbde
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xcbf7
leaq 0x10(%rsp), %rdi
callq 0xbe1e
cmpb $0x1, 0x20(%rbx)
jne 0xcba7
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
callq 0xd03c
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0xc2be
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0xc1a6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xcc76
movq %rsp, %rdi
callq 0xd066
movq 0x10(%rsp), %r14
movq (%rbx), %rdi
movl 0x28(%rbx), %esi
movq %r14, %rdx
callq 0xb530
movq (%rbx), %rdi
movq 0x10(%rbx), %rdx
movl 0x28(%rbx), %ecx
movq %r14, %rsi
callq 0xb958
leaq 0x10(%rsp), %rdi
callq 0xbed2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xe5e9(%rip), %rdi      # 0x1b1ce
leaq 0xe58f(%rip), %rsi      # 0x1b17b
leaq 0xe5eb(%rip), %rcx      # 0x1b1de
pushq $0x2f
jmp 0xcc0e
leaq 0xe611(%rip), %rdi      # 0x1b20f
leaq 0xe576(%rip), %rsi      # 0x1b17b
leaq 0xe5d2(%rip), %rcx      # 0x1b1de
pushq $0x30
popq %rdx
callq 0x4210
jmp 0xcc23
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd066
jmp 0xcc26
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbed2
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x20(%rdi)
je 0xccb8
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x28(%rdi), %rax
jne 0xccd1
movq 0x8(%rsi), %r14
movq 0x8(%rbx), %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xb530
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl 0x28(%rbx), %ecx
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb958
leaq 0xe4b5(%rip), %rdi      # 0x1b174
leaq 0xe4b5(%rip), %rsi      # 0x1b17b
leaq 0xe4bd(%rip), %rcx      # 0x1b18a
pushq $0x27
jmp 0xcce8
leaq 0xe4e7(%rip), %rdi      # 0x1b1bf
leaq 0xe49c(%rip), %rsi      # 0x1b17b
leaq 0xe4a4(%rip), %rcx      # 0x1b18a
pushq $0x28
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x20(%rdi)
jne 0xcd1d
movq 0x8(%r15), %rdi
movq 0x18(%r15), %rax
movslq %ebx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %esi
callq 0xb020
movss (%rax), %xmm0
jmp 0xcd25
movss 0xe44b(%rip), %xmm0     # 0x1b170
movq (%r15), %rdi
movq 0x10(%r15), %rdx
movq %r14, %rsi
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xb804
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
js 0xcda1
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rdx, 0x28(%rdi)
jle 0xcdba
movq %rsi, %r14
movq %rsi, %rdi
callq 0xd074
cmpq 0x30(%r15), %rax
jne 0xcdd3
cmpb $0x1, 0x20(%r15)
jne 0xcd83
movq 0x8(%r15), %rdi
movq 0x18(%r15), %rax
movzbl (%rax,%rbx), %edx
xorl %esi, %esi
callq 0xb020
movss (%rax), %xmm0
jmp 0xcd8b
movss 0xe3e5(%rip), %xmm0     # 0x1b170
movq (%r15), %rdi
movq 0x10(%r15), %rdx
movq %r14, %rsi
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xb712
leaq 0xdb97(%rip), %rdi      # 0x1a93f
leaq 0xe3cc(%rip), %rsi      # 0x1b17b
leaq 0xe469(%rip), %rcx      # 0x1b21f
pushq $0x46
jmp 0xcdea
leaq 0xdf9e(%rip), %rdi      # 0x1ad5f
leaq 0xe3b3(%rip), %rsi      # 0x1b17b
leaq 0xe450(%rip), %rcx      # 0x1b21f
pushq $0x47
jmp 0xcdea
leaq 0xdf8c(%rip), %rdi      # 0x1ad66
leaq 0xe39a(%rip), %rsi      # 0x1b17b
leaq 0xe437(%rip), %rcx      # 0x1b21f
pushq $0x48
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x4430
leaq 0x28(%r14), %rsi
pushq $0x8
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x38(%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x4430
movq 0x10(%r14), %rsi
movslq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x4430
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xb9a8
cmpb $0x1, 0x20(%r14)
jne 0xce8a
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x4430
movq 0x8(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb9a8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x43e0
leaq 0x28(%r14), %rsi
pushq $0x8
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x38(%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x43e0
movslq 0x38(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x43e0
pushq $0x50
popq %rdi
callq 0x4340
movq %rax, %r15
movq %rax, %rdi
callq 0xcfd4
movq %rsp, %r12
andq $0x0, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd008
movq %r12, %rdi
callq 0xcfba
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xba0c
cmpb $0x1, 0x20(%r14)
jne 0xcf95
movq 0x28(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x43e0
pushq $0x50
popq %rdi
callq 0x4340
movq %rax, %r15
movq %rax, %rdi
callq 0xcfd4
leaq 0x8(%r14), %rdi
movq %rsp, %r12
andq $0x0, (%r12)
movq %r15, %rsi
callq 0xd008
movq %r12, %rdi
callq 0xcfba
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xba0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xcfa3
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r15, %rdi
callq 0x4350
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %edx, %edx
testq %rax, %rax
cmovleq %rdx, %rax
xorps %xmm0, %xmm0
cmpq %rdx, %rax
je 0xd0ba
movss (%rcx,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rdx
jmp 0xd0a3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4610
sqrtss %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
testq %rdx, %rdx
js 0xd1e6
cmpq %rdx, 0x8(%rsi)
jle 0xd1ff
movq (%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xd218
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 0xd1e4
movss (%rdx,%rsi,4), %xmm0
addss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
jmp 0xd1cb
popq %rax
retq
leaq 0xd752(%rip), %rdi      # 0x1a93f
leaq 0xe079(%rip), %rsi      # 0x1b26d
leaq 0xe0e8(%rip), %rcx      # 0x1b2e3
pushq $0x46
jmp 0xd22f
leaq 0xe114(%rip), %rdi      # 0x1b31a
leaq 0xe060(%rip), %rsi      # 0x1b26d
leaq 0xe0cf(%rip), %rcx      # 0x1b2e3
pushq $0x47
jmp 0xd22f
leaq 0xe104(%rip), %rdi      # 0x1b323
leaq 0xe047(%rip), %rsi      # 0x1b26d
leaq 0xe0b6(%rip), %rcx      # 0x1b2e3
pushq $0x48
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
testq %rdx, %rdx
js 0xd282
cmpq %rdx, 0x8(%rsi)
jle 0xd29b
movq (%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xd2b4
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 0xd280
movss (%rdx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rcx,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
jmp 0xd263
popq %rax
retq
leaq 0xd6b6(%rip), %rdi      # 0x1a93f
leaq 0xdfdd(%rip), %rsi      # 0x1b26d
leaq 0xe097(%rip), %rcx      # 0x1b32e
pushq $0x4f
jmp 0xd2cb
leaq 0xe078(%rip), %rdi      # 0x1b31a
leaq 0xdfc4(%rip), %rsi      # 0x1b26d
leaq 0xe07e(%rip), %rcx      # 0x1b32e
pushq $0x50
jmp 0xd2cb
leaq 0xe068(%rip), %rdi      # 0x1b323
leaq 0xdfab(%rip), %rsi      # 0x1b26d
leaq 0xe065(%rip), %rcx      # 0x1b32e
pushq $0x51
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
cmpq (%rdi), %rax
jne 0xd35b
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rcx
cmpq (%rdx), %rcx
jne 0xd374
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %rax, %r12
jge 0xd34f
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xbf6c
movq 0x8(%r15), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
movq (%r15), %rax
jmp 0xd32a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe041(%rip), %rdi      # 0x1b3a3
leaq 0xdf04(%rip), %rsi      # 0x1b26d
leaq 0xe03e(%rip), %rcx      # 0x1b3ae
pushq $0x5d
jmp 0xd38b
leaq 0xe06e(%rip), %rdi      # 0x1b3e9
leaq 0xdeeb(%rip), %rsi      # 0x1b26d
leaq 0xe025(%rip), %rcx      # 0x1b3ae
pushq $0x5e
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xcdf0
cmpq (%r15), %rax
jne 0xd3ee
movq %r14, %rdi
callq 0xcdf6
cmpq (%rbx), %rax
jne 0xd407
xorl %r12d, %r12d
cmpq (%r15), %r12
jge 0xd3e2
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xcd3c
movq 0x8(%r15), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
jmp 0xd3c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe003(%rip), %rdi      # 0x1b3f8
leaq 0xde71(%rip), %rsi      # 0x1b26d
leaq 0xe004(%rip), %rcx      # 0x1b407
pushq $0x65
jmp 0xd41e
leaq 0xe035(%rip), %rdi      # 0x1b443
leaq 0xde58(%rip), %rsi      # 0x1b26d
leaq 0xdfeb(%rip), %rcx      # 0x1b407
pushq $0x66
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movss (%rdx), %xmm0
pushq $0x1
popq %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
jge 0xd451
movss (%rdx,%rsi,4), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %rsi, %rax
maxss %xmm0, %xmm1
incq %rsi
movaps %xmm1, %xmm0
jmp 0xd434
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x8(%rdi,%rax)
xorl %r15d, %r15d
pushq $0x20
popq %rbp
cmpq (%r14), %r15
jge 0xd4b6
movq 0x8(%r14), %rax
movss (%rax,%r15,4), %xmm0
movq %rbx, %rdi
callq 0x4270
movq %rax, %rdi
movl %ebp, %esi
callq 0x4390
incq %r15
jmp 0xd490
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/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), quant_(false)
{
  wi_ = wi;
  wo_ = wo;
  args_ = args;
  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, %r15d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, 0x40(%rsp)
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rcx), %rax
movslq 0x94(%rax), %rsi
movq %r14, %rdi
callq 0xd03c
leaq 0x60(%rbx), %r12
movq (%rbp), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, 0x38(%rsp)
callq 0xd03c
movq %r12, 0x30(%rsp)
leaq 0x70(%rbx), %rdi
movq (%r13), %rax
movslq 0x94(%rax), %rsi
movq %rdi, 0x28(%rsp)
callq 0xd03c
leaq 0x10(%rbx), %r14
leaq 0x40(%rbx), %r12
leaq 0xa8(%rbx), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0xb8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
leaq 0xc8(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0xe0(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0xf8(%rbx), %rax
movq %rax, 0x8(%rsp)
movslq %r15d, %rax
xorl %ecx, %ecx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rsi
cmpq $0x1, %rdx
adcq %rcx, %rdx
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xd8(%rbx)
andq $0x0, 0x108(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movq %rdx, 0x110(%rbx)
movb $0x0, 0x118(%rbx)
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq 0xeb34
movq %r14, %rdi
movq %rbp, %rsi
callq 0xeb34
movq %r12, %rdi
movq %r13, %rsi
callq 0xeb9a
movq (%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x88(%rbx)
movq (%r13), %rax
movl 0x94(%rax), %eax
movl %eax, 0x80(%rbx)
andq $0x0, 0xc0(%rbx)
andl $0x0, 0x8c(%rbx)
movq $0x1, 0x90(%rbx)
movq %rbx, %rdi
callq 0xd6e2
movq %rbx, %rdi
callq 0xd758
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xd695
movq %rax, %r14
jmp 0xd69f
movq %rax, %r14
jmp 0xd6a9
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xec96
movq 0x10(%rsp), %rdi
callq 0xe918
movq 0x18(%rsp), %rdi
callq 0xe93a
movq 0x20(%rsp), %rdi
callq 0x8c0e
movq 0x28(%rsp), %rdi
callq 0xd066
movq 0x30(%rsp), %rdi
callq 0xd066
movq 0x38(%rsp), %rdi
callq 0xd066
leaq 0x48(%rbx), %rdi
callq 0x8b66
leaq 0x38(%rbx), %rdi
callq 0x8b66
leaq 0x28(%rbx), %rdi
callq 0x8b66
leaq 0x18(%rbx), %rdi
callq 0x8b66
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8b66
movq %r14, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x804, %edi            # imm = 0x804
callq 0x4030
movq %rax, %rbx
movq %rax, 0x98(%r14)
xorl %r14d, %r14d
cmpq $0x2010, %r14           # imm = 0x2010
je 0xd750
cvtsi2ss %r14d, %xmm0
mulss 0xdd42(%rip), %xmm0     # 0x1b458
addss 0xdd3e(%rip), %xmm0     # 0x1b45c
xorps 0xd5db(%rip), %xmm0     # 0x1ad00
callq 0x4560
cvtss2sd %xmm0, %xmm0
movsd 0xd1b2(%rip), %xmm1     # 0x1a8e8
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rbx)
addq $0x10, %r14
addq $0x4, %rbx
jmp 0xd700
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x804, %edi            # imm = 0x804
callq 0x4030
movq %rax, 0xa0(%rbx)
xorl %r14d, %r14d
cmpq $0x201, %r14            # imm = 0x201
je 0xd7ac
cvtsi2sd %r14d, %xmm0
addsd 0xdd17(%rip), %xmm0     # 0x1b4a0
mulsd 0xdd17(%rip), %xmm0     # 0x1b4a8
cvtsd2ss %xmm0, %xmm0
callq 0x4620
movq 0xa0(%rbx), %rax
movss %xmm0, (%rax,%r14,4)
incq %r14
jmp 0xd773
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x20, %rdi
callq 0xebb6
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xebb6
testl %ebp, %ebp
je 0xd88a
movq 0x30(%rbx), %rdi
callq 0xcdf0
movl %eax, 0x88(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, (%rsp)
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x50(%rbx), %r14
movslq %esi, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0xbf6c
movq %rbx, %rdi
callq 0xd95c
cvtsi2ss %ebp, %xmm1
movss %xmm0, 0x4(%rsp)
subss %xmm0, %xmm1
mulss (%rsp), %xmm1
movss %xmm1, (%rsp)
leaq 0x70(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r15, %rdx
movaps %xmm1, %xmm0
callq 0xd236
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movss (%rsp), %xmm0
callq 0xc01c
testl %ebp, %ebp
je 0xd916
xorps %xmm0, %xmm0
movss 0x4(%rsp), %xmm2
ucomiss 0xd85e(%rip), %xmm2     # 0x1b170
jbe 0xd92f
jmp 0xd949
movss 0xd852(%rip), %xmm1     # 0x1b170
movaps %xmm1, %xmm2
subss 0x4(%rsp), %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm2
ja 0xd949
mulss 0xdb29(%rip), %xmm2     # 0x1b460
cvttss2si %xmm2, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xd3b0(%rip), %xmm0     # 0x1ad00
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorps %xmm1, %xmm1
movss 0xdaf5(%rip), %xmm2     # 0x1b45c
ucomiss %xmm0, %xmm2
ja 0xd9b1
ucomiss 0xdaf1(%rip), %xmm0     # 0x1b464
jbe 0xd97f
movss 0xd7f3(%rip), %xmm1     # 0x1b170
jmp 0xd9b1
addss 0xdadd(%rip), %xmm0     # 0x1b464
mulss 0xdad1(%rip), %xmm0     # 0x1b460
mulss 0xdad1(%rip), %xmm0     # 0x1b468
mulss 0xdacd(%rip), %xmm0     # 0x1b46c
cvttss2si %xmm0, %eax
movq 0x98(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss 0xd7b0(%rip), %xmm0     # 0x1b170
ja 0xd9dc
mulss 0xda96(%rip), %xmm0     # 0x1b460
cvttss2si %xmm0, %eax
movq 0xa0(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
addq $0x70, %rdi
callq 0xd078
xorl %r15d, %r15d
xorps %xmm0, %xmm0
pushq $0x1
popq %rbp
movq 0x40(%r14), %rax
cmpl 0xb0(%rax), %r15d
jg 0xda4c
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
movl %ebx, %esi
testl %r15d, %r15d
je 0xda2e
callq 0xda58
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
jmp 0xda30
movl %ebp, %edx
movss (%rsp), %xmm0
callq 0xd890
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
incl %r15d
jmp 0xda03
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0xa8(%rdi), %r8
movq 0xb0(%rdi), %r9
subq %r8, %r9
sarq $0x2, %r9
movq 0xc0(%rdi), %rdx
movl (%r8,%rdx,4), %ecx
incq %rdx
movq %rdx, %rax
xorl %edx, %edx
divq %r9
cmpl %esi, %ecx
je 0xda74
movq %rdx, 0xc0(%rdi)
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
addq $0x70, %rdi
callq 0xd078
movslq %ebp, %rax
imulq $0x28, %rax, %r14
addq 0xe0(%rbx), %r14
imulq $0x18, %rax, %r12
addq 0xc8(%rbx), %r12
xorps %xmm0, %xmm0
xorl %r15d, %r15d
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0xdb29
movl (%rax,%r15,4), %ebp
movq %r14, %rdi
movq %r15, %rsi
movss %xmm0, 0x8(%rsp)
callq 0xe95c
movzbl %al, %edx
movq %rbx, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xd890
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
incq %r15
jmp 0xdad1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
cmpb $0x1, 0x118(%rdi)
jne 0xdb6c
movq 0x40(%r14), %rax
cmpb $0x1, 0x12c(%rax)
jne 0xdb6c
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xd392
jmp 0xdb78
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xd304
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd452
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jge 0xdbbb
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd452
movss 0x4(%rsp), %xmm0
maxss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
incq %r15
jmp 0xdb8f
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0xdc33
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd452
movss (%rax), %xmm0
subss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x45f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd452
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd452
movss 0x8(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
incq %r15
movl 0x88(%r14), %eax
jmp 0xdbc7
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0xdc62
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd452
movss (%rax), %xmm0
divss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r15
movl 0x88(%r14), %eax
jmp 0xdc36
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::softmax(int, float)
real Model::softmax(int32_t target, real lr) {
  grad_.zero();
  computeOutputSoftmax();
  for (int32_t i = 0; i < osz_; i++) {
    real label = (i == target) ? 1.0 : 0.0;
    real alpha = lr * (label - output_[i]);
    grad_.addRow(*wo_, i, alpha);
    wo_->addRow(hidden_, i, alpha);
  }
  return -log(output_[target]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0xd078
movq %rbx, %rdi
callq 0xdc6c
leaq 0x60(%rbx), %r15
leaq 0x50(%rbx), %r12
movl %ebp, 0x10(%rsp)
movl %ebp, %ebp
xorl %r13d, %r13d
movslq 0x88(%rbx), %rax
cmpq %rax, %r13
jge 0xdd24
movss 0xd4a4(%rip), %xmm0     # 0x1b170
cmpq %r13, %rbp
je 0xdcd4
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xd452
movss 0xc(%rsp), %xmm0
subss (%rax), %xmm0
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0xd236
movq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movss 0xc(%rsp), %xmm0
callq 0xc01c
incq %r13
jmp 0xdcb8
movslq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xd452
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss 0xd431(%rip), %xmm1     # 0x1b170
ja 0xdd5b
mulss 0xd717(%rip), %xmm1     # 0x1b460
cvttss2si %xmm1, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xcf9e(%rip), %xmm0     # 0x1ad00
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/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) {
    if(quant_) {
      hidden.addRow(*qwi_, *it);
    } else {
      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 0xd074
movslq 0x80(%r15), %rcx
cmpq %rcx, %rax
jne 0xde30
movq %rbx, %rdi
callq 0xd078
movq (%r14), %r13
movq %r13, %r12
negq %r12
cmpq 0x8(%r14), %r13
je 0xdde4
movslq (%r13), %rdx
cmpb $0x1, 0x118(%r15)
jne 0xddcf
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0xd2d2
jmp 0xddda
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xd19e
addq $0x4, %r13
addq $-0x4, %r12
jmp 0xddad
addq (%r14), %r12
negq %r12
sarq $0x2, %r12
movq %r12, %xmm0
punpckldq 0xcb15(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcb1d(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xcad1(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd0cc
leaq 0xd681(%rip), %rdi      # 0x1b4b8
leaq 0xd690(%rip), %rsi      # 0x1b4ce
leaq 0xd696(%rip), %rcx      # 0x1b4db
pushq $0x7b
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::predict(std::vector<int, std::allocator<int>> const&, int, std::vector<std::pair<float, int>, std::allocator<std::pair<float, int>>>&, fasttext::Vector&, fasttext::Vector&) const
void Model::predict(const std::vector<int32_t>& input, int32_t k,
                    std::vector<std::pair<real, int32_t>>& heap,
                    Vector& hidden, Vector& output) const {
  assert(k > 0);
  heap.reserve(k + 1);
  computeHidden(input, hidden);
  if (args_->loss == loss_name::hs) {
    dfs(k, 2 * osz_ - 2, 0.0, heap, hidden);
  } else {
    findKBest(k, heap, hidden, output);
  }
  std::sort_heap(heap.begin(), heap.end(), comparePairs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xdf01
movq %r9, %r13
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %rbp
movq %rdi, %r12
leal 0x1(%r15), %esi
movq %rcx, %rdi
callq 0xe97a
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xdd72
movq 0x40(%r12), %rax
cmpl $0x1, 0xbc(%rax)
jne 0xdecc
movl 0x88(%r12), %eax
leal -0x2(,%rax,2), %edx
xorps %xmm0, %xmm0
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xdf20
jmp 0xdee0
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0xe0ea
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0xa0(%rip), %rdx       # 0xde4e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xea17
leaq 0xd625(%rip), %rdi      # 0x1b52d
leaq 0xd5bf(%rip), %rsi      # 0x1b4ce
leaq 0xd61d(%rip), %rcx      # 0x1b533
movl $0x8f, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/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;
  if (quant_ && args_->qout) {
    f= sigmoid(qwo_->dotRow(hidden, node - osz_));
  } else {
    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 0xdf64
movss (%rax), %xmm0
ucomiss 0x8(%rsp), %xmm0
ja 0xe0da
movslq %edx, %rax
movq 0xf8(%r15), %rcx
movq %rax, %r13
shlq $0x5, %r13
cmpl $-0x1, 0x4(%rcx,%r13)
jne 0xdf8a
addq %r13, %rcx
cmpl $-0x1, 0x8(%rcx)
je 0xe086
cmpb $0x1, 0x118(%r15)
jne 0xdfbc
movq 0x40(%r15), %rcx
cmpb $0x1, 0x12c(%rcx)
jne 0xdfbc
movq 0x30(%r15), %rdi
movslq 0x88(%r15), %rcx
subq %rcx, %rax
movq %r14, %rsi
movq %rax, %rdx
callq 0xcd3c
jmp 0xdfd5
movq 0x10(%r15), %rdi
movslq 0x88(%r15), %rcx
subq %rcx, %rax
movq %r14, %rsi
movq %rax, %rdx
callq 0xbf6c
movq %r15, %rdi
callq 0xd95c
movaps %xmm0, %xmm2
movq 0xf8(%r15), %rax
movl 0x4(%rax,%r13), %edx
movss 0xd17c(%rip), %xmm0     # 0x1b170
movaps %xmm0, %xmm1
movss %xmm2, 0xc(%rsp)
subss %xmm2, %xmm1
ucomiss %xmm0, %xmm1
xorps %xmm0, %xmm0
ja 0xe023
mulss 0xd44f(%rip), %xmm1     # 0x1b460
cvttss2si %xmm1, %eax
movq 0xa0(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
addss 0x8(%rsp), %xmm0
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xdf20
movq 0xf8(%r15), %rax
movl 0x8(%rax,%r13), %edx
movss 0xc(%rsp), %xmm0
ucomiss 0xd11e(%rip), %xmm0     # 0x1b170
xorps %xmm1, %xmm1
ja 0xe071
mulss 0xd401(%rip), %xmm0     # 0x1b460
cvttss2si %xmm0, %eax
movq 0xa0(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movss 0x8(%rsp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0xdf42
leaq 0x10(%rsp), %rsi
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rsi)
movl %edx, 0x4(%rsi)
movq %rbx, %rdi
callq 0xef42
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x260(%rip), %rdx      # 0xde4e
callq 0xea28
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0xe0da
leaq -0x282(%rip), %rdx      # 0xde4e
callq 0xea46
addq $-0x8, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop