LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdef6
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rdx, 0x8(%rdi)
jle 0xdf15
movq %rsi, %r14
movq %rsi, %rdi
callq 0xefc8
movq 0x10(%r15), %rcx
cmpq %rcx, %rax
jne 0xdf34
testq %rcx, %rcx
jle 0xdeed
imulq %rcx, %rbx
shlq $0x2, %rbx
addq (%r15), %rbx
movq 0x8(%r14), %rax
xorps %xmm0, %xmm0
xorl %edx, %edx
movss (%rbx,%rdx,4), %xmm1
mulss (%rax,%rdx,4), %xmm1
addss %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0xded5
jmp 0xdef0
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10a3b(%rip), %rdi     # 0x1e938
leaq 0x10e10(%rip), %rsi     # 0x1ed14
leaq 0x10e17(%rip), %rcx     # 0x1ed22
movl $0x45, %edx
callq 0x41d0
leaq 0x10e43(%rip), %rdi     # 0x1ed5f
leaq 0x10df1(%rip), %rsi     # 0x1ed14
leaq 0x10df8(%rip), %rcx     # 0x1ed22
movl $0x46, %edx
callq 0x41d0
leaq 0x10e2b(%rip), %rdi     # 0x1ed66
leaq 0x10dd2(%rip), %rsi     # 0x1ed14
leaq 0x10dd9(%rip), %rcx     # 0x1ed22
movl $0x47, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdfc9
movq %rdx, %rbx
movq %rdi, %r14
movss %xmm0, 0xc(%rsp)
cmpq %rdx, 0x8(%rdi)
jle 0xdfe8
movq %rsi, %r15
movq %rsi, %rdi
callq 0xefc8
movq 0x10(%r14), %rcx
cmpq %rcx, %rax
jne 0xe007
testq %rcx, %rcx
movss 0xc(%rsp), %xmm1
jle 0xdfbf
movq 0x8(%r15), %rax
imulq %rcx, %rbx
shlq $0x2, %rbx
addq (%r14), %rbx
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm0
mulss %xmm1, %xmm0
addss (%rbx,%rdx,4), %xmm0
movss %xmm0, (%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xdfa4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10968(%rip), %rdi     # 0x1e938
leaq 0x10d3d(%rip), %rsi     # 0x1ed14
leaq 0x10d99(%rip), %rcx     # 0x1ed77
movl $0x50, %edx
callq 0x41d0
leaq 0x10d70(%rip), %rdi     # 0x1ed5f
leaq 0x10d1e(%rip), %rsi     # 0x1ed14
leaq 0x10d7a(%rip), %rcx     # 0x1ed77
movl $0x51, %edx
callq 0x41d0
leaq 0x10d58(%rip), %rdi     # 0x1ed66
leaq 0x10cff(%rip), %rsi     # 0x1ed14
leaq 0x10d5b(%rip), %rcx     # 0x1ed77
movl $0x52, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe048
movq 0x8(%r12), %r14
movq %r15, %rdi
callq 0xefc8
cmpq %rax, %r14
jg 0xe0ca
cmpq %rbx, %r14
jle 0xe0bb
leaq (,%rbx,4), %r13
movq %rbx, %rbp
movq %rbp, %rsi
subq %rbx, %rsi
movq %r15, %rdi
callq 0xf3dc
movss (%rax), %xmm0
ucomiss 0x10c92(%rip), %xmm0    # 0x1ed10
jne 0xe082
jnp 0xe0af
movq 0x10(%r12), %rax
testq %rax, %rax
jle 0xe0af
movq %rax, %rcx
imulq %r13, %rcx
addq (%r12), %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0xe099
incq %rbp
addq $0x4, %r13
cmpq %r14, %rbp
jne 0xe065
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10ce3(%rip), %rdi     # 0x1edb4
leaq 0x10c3c(%rip), %rsi     # 0x1ed14
leaq 0x10ce7(%rip), %rcx     # 0x1edc6
movl $0x5a, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe10c
movq 0x8(%r12), %r14
movq %r15, %rdi
callq 0xefc8
cmpq %rax, %r14
jg 0xe18e
cmpq %rbx, %r14
jle 0xe17f
leaq (,%rbx,4), %r13
movq %rbx, %rbp
movq %rbp, %rsi
subq %rbx, %rsi
movq %r15, %rdi
callq 0xf3dc
movss (%rax), %xmm0
ucomiss 0x10bce(%rip), %xmm0    # 0x1ed10
jne 0xe146
jnp 0xe173
movq 0x10(%r12), %rax
testq %rax, %rax
jle 0xe173
movq %rax, %rcx
imulq %r13, %rcx
addq (%r12), %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0xe15d
incq %rbp
addq $0x4, %r13
cmpq %r14, %rbp
jne 0xe129
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10c76(%rip), %rdi     # 0x1ee0b
leaq 0x10b78(%rip), %rsi     # 0x1ed14
leaq 0x10c7c(%rip), %rcx     # 0x1ee1f
movl $0x67, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0xe1e6
imulq %rax, %rsi
shlq $0x2, %rsi
addq (%rdi), %rsi
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm2
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xe1cd
ucomisd %xmm1, %xmm0
jb 0xe1f2
sqrtsd %xmm0, %xmm0
jmp 0xe1f7
callq 0x4250
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x10(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43b0
movq (%r14), %rdi
testq %rdi, %rdi
je 0xe350
callq 0x43e0
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 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xdcf4
movq %r12, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movl $0x124, %edx            # imm = 0x124
callq 0x4550
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0xe3f3
callq 0x4060
cmpl $0x2, (%rax)
jne 0xe436
cmpl $-0x1, %ebp
sete %al
cmpl %ebp, %r12d
setl %cl
orb %al, %cl
je 0xe43b
movl $0x1, %edi
callq 0x4230
incl %r12d
jmp 0xe3b3
movq 0x8(%rbx), %rsi
imulq 0x10(%rbx), %rsi
shlq $0x2, %rsi
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x45c0
cmpq $-0x1, %rax
je 0xe440
movq %rax, (%rbx)
movl %r15d, %edi
callq 0x4650
cmpl $-0x1, %eax
je 0xe445
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x477a
callq 0x478f
callq 0x4765
callq 0x4750
jmp 0xe44c
movq %rax, %r14
movq %rbx, %rdi
callq 0xdde0
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41c0
cmpl $-0x1, %eax
je 0xe48e
movq $0x0, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xdde0
callq 0x47b4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
xorps %xmm0, %xmm0
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)
movl $0x50, %edi
callq 0x42f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xccaa
movq $0x0, (%rsp)
movq (%rbx), %rsi
movq %r13, (%rbx)
testq %rsi, %rsi
je 0xe94e
movq %rbx, %rdi
callq 0xef62
movq (%rsp), %rsi
testq %rsi, %rsi
je 0xe95f
movq %rsp, %rdi
callq 0xef62
cmpb $0x1, 0x20(%rbx)
jne 0xe9bd
movq 0x28(%rbx), %rdi
callq 0x4030
movq %rax, 0x18(%rbx)
movl $0x50, %edi
callq 0x42f0
movq %rax, %r12
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xccaa
movq $0x0, (%rsp)
movq (%r14), %rsi
movq %r12, (%r14)
testq %rsi, %rsi
je 0xe9ac
movq %r14, %rdi
callq 0xef62
movq (%rsp), %rsi
testq %rsi, %rsi
je 0xe9bd
movq %rsp, %rdi
callq 0xef62
movq %rbx, %rdi
movq %r15, %rsi
callq 0xea34
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x50, %esi
movq %r12, %rdi
jmp 0xe9f1
jmp 0xe9fa
movq %rax, %r15
movl $0x50, %esi
movq %r13, %rdi
callq 0x4300
jmp 0xe9fd
jmp 0xe9fa
movq %rax, %r15
movq (%r14), %rsi
testq %rsi, %rsi
je 0xea0d
movq %r14, %rdi
callq 0xef62
movq $0x0, 0x8(%rbx)
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xea25
movq %rbx, %rdi
callq 0xef62
movq $0x0, (%rbx)
movq %r15, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeae4
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xeb03
leaq 0x10(%rsp), %rdi
callq 0xdd36
cmpb $0x1, 0x20(%rbx)
jne 0xeaad
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
callq 0xef90
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0xe1fe
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
movq $-0x1, %rcx
callq 0xe0ea
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xeba6
movq %rsp, %rdi
callq 0xefba
movq 0x10(%rsp), %r14
movq (%rbx), %rdi
movl 0x28(%rbx), %esi
movq %r14, %rdx
callq 0xd314
movq (%rbx), %rdi
movq 0x10(%rbx), %rdx
movl 0x28(%rbx), %ecx
movq %r14, %rsi
callq 0xd78c
leaq 0x10(%rsp), %rdi
callq 0xdde0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x106e3(%rip), %rdi     # 0x1f1ce
leaq 0x10689(%rip), %rsi     # 0x1f17b
leaq 0x106e5(%rip), %rcx     # 0x1f1de
movl $0x2f, %edx
callq 0x41d0
leaq 0x10705(%rip), %rdi     # 0x1f20f
leaq 0x1066a(%rip), %rsi     # 0x1f17b
leaq 0x106c6(%rip), %rcx     # 0x1f1de
movl $0x30, %edx
callq 0x41d0
jmp 0xeb31
movq %rax, %rbx
movq %rsp, %rdi
callq 0xefba
jmp 0xeb34
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdde0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xebe8
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rax, (%rsi)
jne 0xec07
movq 0x8(%rsi), %r14
movq 0x8(%rbx), %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xd314
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl 0x28(%rbx), %ecx
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd78c
leaq 0x10585(%rip), %rdi     # 0x1f174
leaq 0x10585(%rip), %rsi     # 0x1f17b
leaq 0x1058d(%rip), %rcx     # 0x1f18a
movl $0x27, %edx
callq 0x41d0
leaq 0x105b1(%rip), %rdi     # 0x1f1bf
leaq 0x10566(%rip), %rsi     # 0x1f17b
leaq 0x1056e(%rip), %rcx     # 0x1f18a
movl $0x28, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xec55
movq 0x8(%r15), %rdi
movq 0x18(%r15), %rax
movslq %ebx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %esi
callq 0xcd86
movss (%rax), %xmm0
jmp 0xec5d
movss 0x10513(%rip), %xmm0    # 0x1f170
movq (%r15), %rdi
movq 0x10(%r15), %rdx
movq %r14, %rsi
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xd638
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xecd9
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rdx, 0x28(%rdi)
jle 0xecf8
movq %rsi, %r14
movq %rsi, %rdi
callq 0xefc8
cmpq 0x30(%r15), %rax
jne 0xed17
cmpb $0x1, 0x20(%r15)
jne 0xecbb
movq 0x8(%r15), %rdi
movq 0x18(%r15), %rax
movzbl (%rax,%rbx), %edx
xorl %esi, %esi
callq 0xcd86
movss (%rax), %xmm0
jmp 0xecc3
movss 0x104ad(%rip), %xmm0    # 0x1f170
movq (%r15), %rdi
movq 0x10(%r15), %rdx
movq %r14, %rsi
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xd53a
leaq 0xfc58(%rip), %rdi      # 0x1e938
leaq 0x10494(%rip), %rsi     # 0x1f17b
leaq 0x10531(%rip), %rcx     # 0x1f21f
movl $0x46, %edx
callq 0x41d0
leaq 0x10060(%rip), %rdi     # 0x1ed5f
leaq 0x10475(%rip), %rsi     # 0x1f17b
leaq 0x10512(%rip), %rcx     # 0x1f21f
movl $0x47, %edx
callq 0x41d0
leaq 0x10048(%rip), %rdi     # 0x1ed66
leaq 0x10456(%rip), %rsi     # 0x1f17b
leaq 0x104f3(%rip), %rcx     # 0x1f21f
movl $0x48, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x28(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x30(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x38(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
movq 0x10(%r14), %rsi
movslq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x43f0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd7de
cmpb $0x1, 0x20(%r14)
jne 0xedd5
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x43f0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x28(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x30(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x38(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
movslq 0x38(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x43b0
movl $0x50, %edi
callq 0x42f0
movaps 0xfe51(%rip), %xmm0     # 0x1ecb0
movups %xmm0, (%rax)
movabsq $0x19000004d2, %r12     # imm = 0x19000004D2
movq %r12, 0x10(%rax)
movl $0x33d6bf95, 0x18(%rax) # imm = 0x33D6BF95
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
xorl %ecx, %ecx
movq %rcx, 0x40(%rax)
movq $0x1, 0x48(%rax)
movq %rcx, (%rsp)
movq (%r14), %rsi
movq %rax, (%r14)
testq %rsi, %rsi
je 0xeea3
movq %r14, %rdi
callq 0xef62
movq (%rsp), %rsi
testq %rsi, %rsi
je 0xeeb4
movq %rsp, %rdi
callq 0xef62
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd846
cmpb $0x1, 0x20(%r14)
jne 0xef55
movq 0x28(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x43b0
movl $0x50, %edi
callq 0x42f0
movaps 0xfdb7(%rip), %xmm0     # 0x1ecb0
movups %xmm0, (%rax)
movq %r12, 0x10(%rax)
movl $0x33d6bf95, 0x18(%rax) # imm = 0x33D6BF95
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
xorl %ecx, %ecx
movq %rcx, 0x40(%rax)
movq $0x1, 0x48(%rax)
leaq 0x8(%r14), %r15
movq %rcx, (%rsp)
movq 0x8(%r14), %rsi
movq %rax, 0x8(%r14)
testq %rsi, %rsi
je 0xef39
movq %r15, %rdi
callq 0xef62
movq (%rsp), %rsi
testq %rsi, %rsi
je 0xef4a
movq %rsp, %rdi
callq 0xef62
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xd846
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testq %rax, %rax
jle 0xf00d
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm2
mulss %xmm2, %xmm2
addss %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xeff8
ucomiss %xmm1, %xmm0
jb 0x45f0
sqrtss %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf12a
cmpq %rdx, 0x8(%rsi)
jle 0xf149
movq 0x10(%rsi), %rax
cmpq %rax, (%rdi)
jne 0xf168
testq %rax, %rax
jle 0xf128
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm0
addss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0xf111
popq %rax
retq
leaq 0xf807(%rip), %rdi      # 0x1e938
leaq 0x10135(%rip), %rsi     # 0x1f26d
leaq 0x101a4(%rip), %rcx     # 0x1f2e3
movl $0x46, %edx
callq 0x41d0
leaq 0x101ca(%rip), %rdi     # 0x1f31a
leaq 0x10116(%rip), %rsi     # 0x1f26d
leaq 0x10185(%rip), %rcx     # 0x1f2e3
movl $0x47, %edx
callq 0x41d0
leaq 0x101b4(%rip), %rdi     # 0x1f323
leaq 0x100f7(%rip), %rsi     # 0x1f26d
leaq 0x10166(%rip), %rcx     # 0x1f2e3
movl $0x48, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf1d0
cmpq %rdx, 0x8(%rsi)
jle 0xf1ef
movq 0x10(%rsi), %rax
cmpq %rax, (%rdi)
jne 0xf20e
testq %rax, %rax
jle 0xf1ce
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rcx,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0xf1b3
popq %rax
retq
leaq 0xf761(%rip), %rdi      # 0x1e938
leaq 0x1008f(%rip), %rsi     # 0x1f26d
leaq 0x10149(%rip), %rcx     # 0x1f32e
movl $0x4f, %edx
callq 0x41d0
leaq 0x10124(%rip), %rdi     # 0x1f31a
leaq 0x10070(%rip), %rsi     # 0x1f26d
leaq 0x1012a(%rip), %rcx     # 0x1f32e
movl $0x50, %edx
callq 0x41d0
leaq 0x1010e(%rip), %rdi     # 0x1f323
leaq 0x10051(%rip), %rsi     # 0x1f26d
leaq 0x1010b(%rip), %rcx     # 0x1f32e
movl $0x51, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf2ba
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rax
cmpq (%rdx), %rax
jne 0xf2d9
movq %rdi, %r15
cmpq $0x0, (%rdi)
jle 0xf2ae
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xde92
movq 0x8(%r15), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
cmpq (%r15), %r12
jl 0xf28e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x100e2(%rip), %rdi     # 0x1f3a3
leaq 0xffa5(%rip), %rsi      # 0x1f26d
leaq 0x100df(%rip), %rcx     # 0x1f3ae
movl $0x5d, %edx
callq 0x41d0
leaq 0x10109(%rip), %rdi     # 0x1f3e9
leaq 0xff86(%rip), %rsi      # 0x1f26d
leaq 0x100c0(%rip), %rcx     # 0x1f3ae
movl $0x5e, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xed36
cmpq (%r15), %rax
jne 0xf358
movq %r14, %rdi
callq 0xed3c
cmpq (%rbx), %rax
jne 0xf377
cmpq $0x0, (%r15)
jle 0xf34c
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xec74
movq 0x8(%r15), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
cmpq (%r15), %r12
jl 0xf32c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10099(%rip), %rdi     # 0x1f3f8
leaq 0xff07(%rip), %rsi      # 0x1f26d
leaq 0x1009a(%rip), %rcx     # 0x1f407
movl $0x65, %edx
callq 0x41d0
leaq 0x100c5(%rip), %rdi     # 0x1f443
leaq 0xfee8(%rip), %rsi      # 0x1f26d
leaq 0x1007b(%rip), %rcx     # 0x1f407
movl $0x66, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x2, %rcx
jl 0xf3ca
movq 0x8(%rdi), %rdx
movss (%rdx), %xmm0
movl $0x1, %esi
xorl %eax, %eax
movss (%rdx,%rsi,4), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %rsi, %rax
maxss %xmm0, %xmm1
incq %rsi
movaps %xmm1, %xmm0
cmpq %rsi, %rcx
jne 0xf3ae
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x8(%rdi,%rax)
cmpq $0x0, (%rsi)
jle 0xf447
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
movq 0x8(%r14), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r12,4), %xmm0
movq %rbx, %rdi
callq 0x44e0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4350
incq %r12
cmpq (%r14), %r12
jl 0xf415
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %r8d, %r15d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %r12
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 %r12, %rdi
callq 0xef90
leaq 0x60(%rbx), %rdi
movq (%rbp), %rax
movq 0x8(%rax), %rsi
movq %rdi, 0x18(%rsp)
movq %r12, 0x20(%rsp)
callq 0xef90
leaq 0x70(%rbx), %rdi
movq (%r13), %rax
movslq 0x94(%rax), %rsi
movq %rdi, 0x10(%rsp)
callq 0xef90
leaq 0xa8(%rbx), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
xorl %r12d, %r12d
movq %r12, 0xb8(%rbx)
leaq 0xc8(%rbx), %rax
movq %rax, (%rsp)
movslq %r15d, %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
leaq 0xe0(%rbx), %r15
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movq %r12, 0x108(%rbx)
movq %rax, 0x110(%rbx)
movb $0x0, 0x118(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x10fb4
movq (%rbp), %rax
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
leaq 0x8(%rbp), %rsi
callq 0x10fb4
movq (%r13), %rax
movq %rax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x8(%r13), %rsi
callq 0x10fb4
movq (%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x88(%rbx)
movq (%r13), %rax
movl 0x94(%rax), %eax
movl %eax, 0x80(%rbx)
movq %r12, 0xc0(%rbx)
movl $0x0, 0x8c(%rbx)
movq $0x1, 0x90(%rbx)
movq %rbx, %rdi
callq 0xf690
movq %rbx, %rdi
callq 0xf70a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf66c
movq %rax, %r14
jmp 0xf676
movq %rax, %r14
jmp 0xf680
movq %rax, %r14
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0xf635
movq 0x108(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
movq %r15, %rdi
callq 0x10db8
movq (%rsp), %rdi
callq 0x10de8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xf662
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x10(%rsp), %rdi
callq 0xefba
movq 0x18(%rsp), %rdi
callq 0xefba
movq 0x20(%rsp), %rdi
callq 0xefba
movq %rbx, %rdi
callq 0x4847
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
mulss 0xfd9a(%rip), %xmm0     # 0x1f458
addss 0xfd96(%rip), %xmm0     # 0x1f45c
xorps 0xf633(%rip), %xmm0     # 0x1ed00
callq 0x4530
cvtss2sd %xmm0, %xmm0
movsd 0xf212(%rip), %xmm1     # 0x1e8f0
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rbx)
addq $0x10, %r14
addq $0x4, %rbx
cmpq $0x2010, %r14           # imm = 0x2010
jne 0xf6ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
addsd 0xfd6b(%rip), %xmm0     # 0x1f4a0
mulsd 0xfd6b(%rip), %xmm0     # 0x1f4a8
cvtsd2ss %xmm0, %xmm0
callq 0x4610
movq 0xa0(%rbx), %rax
movss %xmm0, (%rax,%r14,4)
incq %r14
cmpq $0x201, %r14            # imm = 0x201
jne 0xf725
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rsi), %rax
movq %rax, 0x20(%rdi)
addq $0x28, %rdi
addq $0x8, %rsi
callq 0x10fb4
movq (%r14), %rax
movq %rax, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x10fb4
testl %ebp, %ebp
je 0xf88a
movq 0x30(%rbx), %rdi
callq 0xed36
movl %eax, 0x88(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde92
xorps %xmm2, %xmm2
movss 0xfb9a(%rip), %xmm1     # 0x1f45c
ucomiss %xmm0, %xmm1
ja 0xf90c
ucomiss 0xfb92(%rip), %xmm0     # 0x1f460
jbe 0xf8da
movss 0xf898(%rip), %xmm2     # 0x1f170
jmp 0xf90c
addss 0xfb7e(%rip), %xmm0     # 0x1f460
mulss 0xfb7a(%rip), %xmm0     # 0x1f464
mulss 0xfb76(%rip), %xmm0     # 0x1f468
mulss 0xfb72(%rip), %xmm0     # 0x1f46c
cvttss2si %xmm0, %eax
movq 0x98(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm2
movzbl %bpl, %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm2, 0x4(%rsp)
subss %xmm2, %xmm0
mulss (%rsp), %xmm0
movss %xmm0, (%rsp)
leaq 0x70(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r15, %rdx
callq 0xf188
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movss (%rsp), %xmm0
callq 0xdf54
testb %bpl, %bpl
je 0xf968
xorps %xmm0, %xmm0
movss 0x4(%rsp), %xmm2
ucomiss 0xf80c(%rip), %xmm2     # 0x1f170
jbe 0xf981
jmp 0xf99b
movss 0xf800(%rip), %xmm1     # 0x1f170
movaps %xmm1, %xmm2
subss 0x4(%rsp), %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm2
ja 0xf99b
mulss 0xfadb(%rip), %xmm2     # 0x1f464
cvttss2si %xmm2, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xf35e(%rip), %xmm0     # 0x1ed00
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfaa3(%rip), %xmm2     # 0x1f45c
ucomiss %xmm0, %xmm2
ja 0xfa03
ucomiss 0xfa9b(%rip), %xmm0     # 0x1f460
jbe 0xf9d1
movss 0xf7a1(%rip), %xmm1     # 0x1f170
jmp 0xfa03
addss 0xfa87(%rip), %xmm0     # 0x1f460
mulss 0xfa83(%rip), %xmm0     # 0x1f464
mulss 0xfa7f(%rip), %xmm0     # 0x1f468
mulss 0xfa7b(%rip), %xmm0     # 0x1f46c
cvttss2si %xmm0, %eax
movq 0x98(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf75e(%rip), %xmm0     # 0x1f170
ja 0xfa2e
mulss 0xfa48(%rip), %xmm0     # 0x1f464
cvttss2si %xmm0, %eax
movq 0xa0(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
addq $0x70, %rdi
callq 0xefcc
movq 0x40(%r14), %rax
cmpl $0x0, 0xb0(%rax)
js 0xfae5
xorps %xmm0, %xmm0
xorl %r15d, %r15d
testl %r15d, %r15d
movss %xmm0, 0xc(%rsp)
je 0xfaad
movq 0xa8(%r14), %rcx
movq 0xb0(%r14), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq 0xc0(%r14), %rdx
movl (%rcx,%rdx,4), %esi
incq %rdx
movq %rdx, %rax
xorl %edx, %edx
divq %rdi
cmpl %ebx, %esi
je 0xfa8d
movq %rdx, 0xc0(%r14)
movq %r14, %rdi
xorl %edx, %edx
jmp 0xfab7
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movss 0x8(%rsp), %xmm0
callq 0xf890
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
leal 0x1(%r15), %eax
movq 0x40(%r14), %rcx
cmpl 0xb0(%rcx), %r15d
movl %eax, %r15d
jl 0xfa66
jmp 0xfae8
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfb0e
movq %rdx, 0xc0(%rdi)
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xefcc
movslq %ebp, %rsi
movq 0xc8(%rbx), %rcx
leaq (%rsi,%rsi,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0xfbdb
leaq (%rsi,%rsi,4), %r14
shlq $0x3, %r14
addq 0xe0(%rbx), %r14
leaq (%rcx,%rdx,8), %r15
xorps %xmm0, %xmm0
xorl %r12d, %r12d
movss %xmm0, 0x8(%rsp)
movl (%rax,%r12,4), %esi
movq (%r14), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
xorl %edx, %edx
btq %r12, %rax
setb %dl
movq %rbx, %rdi
movss 0xc(%rsp), %xmm0
callq 0xf890
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
incq %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0xfb7e
jmp 0xfbde
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfc22
movq 0x40(%r14), %rax
cmpb $0x1, 0x12c(%rax)
jne 0xfc22
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xf2f8
jmp 0xfc2e
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xf262
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf3ce
movss (%rax), %xmm0
cmpl $0x0, 0x88(%r14)
jle 0xfc73
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf3ce
movss 0x8(%rsp), %xmm0
maxss (%rax), %xmm0
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xfc49
cmpl $0x0, 0x88(%r14)
jle 0xfcf2
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf3ce
movss (%rax), %xmm0
subss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x45d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf3ce
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf3ce
movss 0x4(%rsp), %xmm1
addss (%rax), %xmm1
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xfc89
jmp 0xfcf5
xorps %xmm1, %xmm1
cmpl $0x0, 0x88(%r14)
jle 0xfd34
xorl %r15d, %r15d
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf3ce
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xfd08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0xefcc
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xfbec
cmpl $0x0, 0x88(%rbx)
jle 0xfe03
movl 0x10(%rsp), %ebp
xorl %r13d, %r13d
movss 0xf3cf(%rip), %xmm0     # 0x1f170
cmpq %r13, %rbp
je 0xfda9
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xf3ce
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 0xf188
movq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movss 0xc(%rsp), %xmm0
callq 0xdf54
incq %r13
movslq 0x88(%rbx), %rax
cmpq %rax, %r13
jl 0xfd99
movslq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xf3ce
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss 0xf352(%rip), %xmm1     # 0x1f170
ja 0xfe3a
mulss 0xf63c(%rip), %xmm1     # 0x1f464
cvttss2si %xmm1, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xeebf(%rip), %xmm0     # 0x1ed00
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xefc8
movslq 0x80(%r15), %rcx
cmpq %rcx, %rax
jne 0xff05
movq %rbx, %rdi
callq 0xefcc
movq (%r14), %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
je 0xfeba
movslq (%r12), %rdx
cmpb $0x1, 0x118(%r15)
jne 0xfea9
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0xf22e
jmp 0xfeb4
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xf0e6
addq $0x4, %r12
jmp 0xfe84
subq (%r14), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xea42(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xea4a(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xea06(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf01c
leaq 0xf5a4(%rip), %rdi      # 0x1f4b0
leaq 0xf5b3(%rip), %rsi      # 0x1f4c6
leaq 0xf5b9(%rip), %rcx      # 0x1f4d3
movl $0x7b, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xffde
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 0x10e36
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xfe50
movq 0x40(%r12), %rax
cmpl $0x1, 0xbc(%rax)
jne 0xffa2
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 0xfffe
jmp 0xffb6
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x10356
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0xa0(%rip), %rax       # 0xff24
movq %rsp, %rdx
movq %rax, (%rdx)
callq 0x11045
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf540(%rip), %rdi      # 0x1f525
leaq 0xf4da(%rip), %rsi      # 0x1f4c6
leaq 0xf538(%rip), %rcx      # 0x1f52b
movl $0x8f, %edx
callq 0x41d0
nop