LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfb96(%rip), %xmm0     # 0x1f470
addss 0xfb92(%rip), %xmm0     # 0x1f474
xorps 0xf3f7(%rip), %xmm0     # 0x1ece0
callq 0x4530
cvtss2sd %xmm0, %xmm0
movsd 0xeffe(%rip), %xmm1     # 0x1e8f8
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 0xf8ca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfb5f(%rip), %xmm0     # 0x1f4b0
mulsd 0xfb5f(%rip), %xmm0     # 0x1f4b8
cvtsd2ss %xmm0, %xmm0
callq 0x4610
movq 0xa0(%rbx), %rax
movss %xmm0, (%rax,%r14,4)
incq %r14
cmpq $0x201, %r14            # imm = 0x201
jne 0xf941
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10fcc
movq (%r14), %rax
movq %rax, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x10fcc
testl %ebp, %ebp
je 0xfaa6
movq 0x30(%rbx), %rdi
callq 0xef68
movl %eax, 0x88(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe10c
xorps %xmm2, %xmm2
movss 0xf996(%rip), %xmm1     # 0x1f474
ucomiss %xmm0, %xmm1
ja 0xfb28
ucomiss 0xf98e(%rip), %xmm0     # 0x1f478
jbe 0xfaf6
movss 0xf694(%rip), %xmm2     # 0x1f188
jmp 0xfb28
addss 0xf97a(%rip), %xmm0     # 0x1f478
mulss 0xf976(%rip), %xmm0     # 0x1f47c
mulss 0xf972(%rip), %xmm0     # 0x1f480
mulss 0xf96e(%rip), %xmm0     # 0x1f484
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 0xf3a4
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movss (%rsp), %xmm0
callq 0xe1ca
testb %bpl, %bpl
je 0xfb84
xorps %xmm0, %xmm0
movss 0x4(%rsp), %xmm2
ucomiss 0xf608(%rip), %xmm2     # 0x1f188
jbe 0xfb9d
jmp 0xfbb7
movss 0xf5fc(%rip), %xmm1     # 0x1f188
movaps %xmm1, %xmm2
subss 0x4(%rsp), %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm2
ja 0xfbb7
mulss 0xf8d7(%rip), %xmm2     # 0x1f47c
cvttss2si %xmm2, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xf122(%rip), %xmm0     # 0x1ece0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf89f(%rip), %xmm2     # 0x1f474
ucomiss %xmm0, %xmm2
ja 0xfc1f
ucomiss 0xf897(%rip), %xmm0     # 0x1f478
jbe 0xfbed
movss 0xf59d(%rip), %xmm1     # 0x1f188
jmp 0xfc1f
addss 0xf883(%rip), %xmm0     # 0x1f478
mulss 0xf87f(%rip), %xmm0     # 0x1f47c
mulss 0xf87b(%rip), %xmm0     # 0x1f480
mulss 0xf877(%rip), %xmm0     # 0x1f484
cvttss2si %xmm0, %eax
movq 0x98(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf55a(%rip), %xmm0     # 0x1f188
ja 0xfc4a
mulss 0xf844(%rip), %xmm0     # 0x1f47c
cvttss2si %xmm0, %eax
movq 0xa0(%rdi), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf1e8
movq 0x40(%r14), %rax
cmpl $0x0, 0xb0(%rax)
js 0xfd01
xorps %xmm0, %xmm0
xorl %r15d, %r15d
testl %r15d, %r15d
movss %xmm0, 0xc(%rsp)
je 0xfcc9
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 0xfca9
movq %rdx, 0xc0(%r14)
movq %r14, %rdi
xorl %edx, %edx
jmp 0xfcd3
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movss 0x8(%rsp), %xmm0
callq 0xfaac
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 0xfc82
jmp 0xfd04
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf1e8
movslq %ebp, %rsi
movq 0xc8(%rbx), %rcx
leaq (%rsi,%rsi,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0xfdf6
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
movl %r12d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
xorl %edx, %edx
btq %r12, %rax
setb %dl
movq %rbx, %rdi
movss 0xc(%rsp), %xmm0
callq 0xfaac
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 0xfd9a
jmp 0xfdf9
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe3c
movq 0x40(%r14), %rax
cmpb $0x1, 0x12c(%rax)
jne 0xfe3c
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xf514
jmp 0xfe48
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xf47e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf5ea
cmpl $0x0, 0x88(%r14)
jle 0xff45
movss (%rax), %xmm0
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5ea
movss 0x8(%rsp), %xmm0
maxss (%rax), %xmm0
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xfe67
testl %eax, %eax
jle 0xff45
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5ea
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 0xf5ea
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5ea
movss 0x4(%rsp), %xmm1
addss (%rax), %xmm1
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xfea5
testl %eax, %eax
jle 0xff45
xorl %r15d, %r15d
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5ea
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
incq %r15
movslq 0x88(%r14), %rax
cmpq %rax, %r15
jl 0xff13
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf1e8
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xfe06
cmpl $0x0, 0x88(%rbx)
jle 0x10015
movl 0x10(%rsp), %ebp
xorl %r13d, %r13d
movss 0xf1d5(%rip), %xmm0     # 0x1f188
cmpq %r13, %rbp
je 0xffbb
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xf5ea
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 0xf3a4
movq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movss 0xc(%rsp), %xmm0
callq 0xe1ca
incq %r13
movslq 0x88(%rbx), %rax
cmpq %rax, %r13
jl 0xffab
movslq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xf5ea
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss 0xf158(%rip), %xmm1     # 0x1f188
ja 0x1004c
mulss 0xf442(%rip), %xmm1     # 0x1f47c
cvttss2si %xmm1, %eax
movq 0xa0(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
xorps 0xec8d(%rip), %xmm0     # 0x1ece0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf1e4
movslq 0x80(%r15), %rcx
cmpq %rcx, %rax
jne 0x10120
movq %rbx, %rdi
callq 0xf1e8
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x100d2
movslq (%r12), %rdx
cmpb $0x1, 0x118(%r15)
jne 0x100b8
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0xf44a
jmp 0x100c3
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xf302
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jne 0x1009c
movq (%r14), %rax
jmp 0x100d5
movq %r12, %rax
subq %rax, %r12
sarq $0x2, %r12
movq %r12, %xmm0
punpckldq 0xe827(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe82f(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xe7f3(%rip), %xmm0     # 0x1e8f8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf238
leaq 0xf399(%rip), %rdi      # 0x1f4c0
leaq 0xf3a8(%rip), %rsi      # 0x1f4d6
leaq 0xf3ae(%rip), %rcx      # 0x1f4e3
movl $0x7b, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x101fa
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 0x10e4e
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x10062
movq 0x40(%r12), %rax
cmpl $0x1, 0xbc(%rax)
jne 0x101be
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 0x1021a
jmp 0x101d2
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x10478
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0xa0(%rip), %rax       # 0x10140
movq %rsp, %rdx
movq %rax, (%rdx)
callq 0x11061
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf334(%rip), %rdi      # 0x1f535
leaq 0xf2ce(%rip), %rsi      # 0x1f4d6
leaq 0xf32c(%rip), %rcx      # 0x1f53b
movl $0x8f, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::findKBest(int, std::vector<std::pair<float, int>, std::allocator<std::pair<float, int>>>&, fasttext::Vector&, fasttext::Vector&) const
void Model::findKBest(int32_t k, std::vector<std::pair<real, int32_t>>& heap,
                      Vector& hidden, Vector& output) const {
  computeOutputSoftmax(hidden, output);
  for (int32_t i = 0; i < osz_; i++) {
    if (heap.size() == k && log(output[i]) < heap.front().first) {
      continue;
    }
    heap.push_back(std::make_pair(log(output[i]), i));
    std::push_heap(heap.begin(), heap.end(), comparePairs);
    if (heap.size() > k) {
      std::pop_heap(heap.begin(), heap.end(), comparePairs);
      heap.pop_back();
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rsi
movq %r8, 0x8(%rsp)
movq %r8, %rdx
callq 0xfe06
cmpl $0x0, 0x88(%r15)
jle 0x105fb
movslq %ebp, %r13
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jne 0x1050b
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf5ea
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss 0xeca9(%rip), %xmm1     # 0x1f188
ja 0x104fb
mulss 0xef93(%rip), %xmm1     # 0x1f47c
cvttss2si %xmm1, %eax
movq 0xa0(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
movq (%r14), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
ja 0x105db
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf5ea
movss (%rax), %xmm0
ucomiss 0xec65(%rip), %xmm0     # 0x1f188
jbe 0x10529
xorl %eax, %eax
jmp 0x10541
mulss 0xef4b(%rip), %xmm0     # 0x1f47c
cvttss2si %xmm0, %eax
movq 0xa0(%r15), %rcx
cltq
movl (%rcx,%rax,4), %eax
addq %r12, %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x11234
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq -0x427(%rip), %rax      # 0x10140
movq %rax, 0x10(%rsp)
movq -0x8(%rsi), %rcx
subq %rdi, %rsi
sarq $0x3, %rsi
decq %rsi
xorl %edx, %edx
movq %rbx, %r8
callq 0x111a5
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x105db
cmpq $0x9, %rcx
jl 0x105d3
leaq -0x8(%rax), %rdx
movq -0x8(%rax), %rcx
movss (%rdi), %xmm0
movss %xmm0, -0x8(%rax)
movl 0x4(%rdi), %esi
movl %esi, -0x4(%rax)
subq %rdi, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
leaq -0x48a(%rip), %r8       # 0x10140
callq 0x110c5
movq 0x8(%r14), %rax
addq $-0x8, %rax
movq %rax, 0x8(%r14)
incq %rbp
movslq 0x88(%r15), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %r12
cmpq %rax, %rbp
jl 0x104b4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::update(std::vector<int, std::allocator<int>> const&, int, float)
void Model::update(const std::vector<int32_t>& input, int32_t target, real lr) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return;
  computeHidden(input, hidden_);
  if (args_->loss == loss_name::ns) {
    loss_ += negativeSampling(target, lr);
  } else if (args_->loss == loss_name::hs) {
    loss_ += hierarchicalSoftmax(target, lr);
  } else {
    loss_ += softmax(target, lr);
  }
  nexamples_ += 1;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
js 0x10745
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x88(%rdi)
jle 0x10764
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x10738
movss %xmm0, 0xc(%rsp)
leaq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10062
movq 0x40(%r14), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x10688
cmpl $0x2, %eax
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
jne 0x1069a
callq 0xfc4e
jmp 0x1069f
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xfd48
jmp 0x1069f
callq 0xff5e
addss 0x8c(%r14), %xmm0
movss %xmm0, 0x8c(%r14)
incq 0x90(%r14)
movq 0x40(%r14), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x1070a
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xe233(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe23b(%rip), %xmm0     # 0x1e920
leaq 0x70(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xe1fb(%rip), %xmm0     # 0x1e8f8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xf238
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x10738
leaq 0x70(%r14), %r15
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0xea5f(%rip), %xmm0     # 0x1f188
callq 0xe1ca
addq $0x4, %r12
cmpq 0x8(%rbx), %r12
jne 0x10717
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xee77(%rip), %rdi      # 0x1f5c3
leaq 0xed83(%rip), %rsi      # 0x1f4d6
leaq 0xee75(%rip), %rcx      # 0x1f5cf
movl $0xcc, %edx
callq 0x41d0
leaq 0xeeae(%rip), %rdi      # 0x1f619
leaq 0xed64(%rip), %rsi      # 0x1f4d6
leaq 0xee56(%rip), %rcx      # 0x1f5cf
movl $0xcd, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::update(std::vector<int, std::allocator<int>> const&, int, float, float, int, int)
void Model::update(const std::vector<int32_t>& input, int32_t target, real lr, real boostNgrams, int32_t lowIdx, int32_t hiIdx) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return;
  computeHidden(input, hidden_);
  if (args_->loss == loss_name::ns) {
    loss_ += negativeSampling(target, lr);
  } else if (args_->loss == loss_name::hs) {
    loss_ += hierarchicalSoftmax(target, lr);
  } else {
    loss_ += softmax(target, lr);
  }
  nexamples_ += 1;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
testl %edx, %edx
js 0x10881
movl %edx, %r12d
movq %rdi, %r15
cmpl %edx, 0x88(%rdi)
jle 0x108a0
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x10872
movl %r8d, %ebx
movl %ecx, %ebp
movss %xmm0, (%rsp)
leaq 0x50(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10062
movq 0x40(%r15), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x107fe
cmpl $0x2, %eax
movss (%rsp), %xmm0
movq %r15, %rdi
movl %r12d, %esi
jne 0x10810
callq 0xfc4e
jmp 0x10815
movq %r15, %rdi
movl %r12d, %esi
movss (%rsp), %xmm0
callq 0xfd48
jmp 0x10815
callq 0xff5e
addss 0x8c(%r15), %xmm0
movss %xmm0, 0x8c(%r15)
incq 0x90(%r15)
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x10872
leaq 0x70(%r15), %r12
movslq (%r13), %rdx
movss 0x4(%rsp), %xmm0
cmpl %ebx, %edx
jl 0x10851
movss 0xe937(%rip), %xmm0     # 0x1f188
cmpl %ebp, %edx
jg 0x1085d
movss 0xe92b(%rip), %xmm0     # 0x1f188
movq (%r15), %rdi
movq %r12, %rsi
callq 0xe1ca
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x1083b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed3b(%rip), %rdi      # 0x1f5c3
leaq 0xec47(%rip), %rsi      # 0x1f4d6
leaq 0xed91(%rip), %rcx      # 0x1f627
movl $0xe2, %edx
callq 0x41d0
leaq 0xed72(%rip), %rdi      # 0x1f619
leaq 0xec28(%rip), %rsi      # 0x1f4d6
leaq 0xed72(%rip), %rcx      # 0x1f627
movl $0xe3, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/model.cc
// Function: fasttext::Model::initTableNegatives(std::vector<long, std::allocator<long>> const&)
void Model::initTableNegatives(const std::vector<int64_t>& counts) {
  real z = 0.0;
  for (size_t i = 0; i < counts.size(); i++) {
    z += pow(counts[i], 0.5);
  }
  for (size_t i = 0; i < counts.size(); i++) {
    real c = pow(counts[i], 0.5);
    for (size_t j = 0; j < c * NEGATIVE_TABLE_SIZE / z; j++) {
      negatives.push_back(i);
    }
  }
  std::shuffle(negatives.begin(), negatives.end(), rng);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorps %xmm0, %xmm0
cmpq %rax, %rcx
je 0x109db
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movapd 0xeb14(%rip), %xmm3     # 0x1f490
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jb 0x10991
sqrtsd %xmm0, %xmm0
jmp 0x109a2
callq 0x4250
movapd 0xeaf2(%rip), %xmm3     # 0x1f490
xorpd %xmm2, %xmm2
andpd %xmm3, %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r15
jb 0x1097c
jmp 0x109e1
movss %xmm0, 0x8(%rsp)
cmpq %rax, %rcx
je 0x10ac6
leaq 0xa8(%rbx), %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r13,8), %xmm0
ucomisd 0xdede(%rip), %xmm0     # 0x1e8e8
jb 0x10a12
sqrtsd %xmm0, %xmm0
jmp 0x10a17
callq 0x4250
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
andps 0xea7b(%rip), %xmm1     # 0x1f4a0
mulss 0xea5b(%rip), %xmm1     # 0x1f488
divss 0x8(%rsp), %xmm1
ucomiss 0xe2ee(%rip), %xmm1     # 0x1ed28
jbe 0x10aac
movl $0x1, %ebp
movaps %xmm1, 0x10(%rsp)
movl %r13d, 0xc(%rsp)
movq 0xb0(%rbx), %rsi
cmpq 0xb8(%rbx), %rsi
je 0x10a6b
movl %r13d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%rbx)
jmp 0x10a7b
movq %r15, %rdi
movq %r12, %rdx
callq 0xb082
movaps 0x10(%rsp), %xmm1
testq %rbp, %rbp
js 0x10a8a
xorps %xmm0, %xmm0
cvtsi2ss %rbp, %xmm0
jmp 0x10aa4
movq %rbp, %rax
shrq %rax
movl %ebp, %ecx
andl $0x1, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
incq %rbp
ucomiss %xmm0, %xmm1
ja 0x10a46
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x109f9
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rsi
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdx
callq 0xdc78
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::getVector(fasttext::Vector&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void FastText::getVector(Vector& vec, const std::string& word) const {
  const std::vector<int32_t>& ngrams = dict_->getNgrams(word);
  vec.zero();
  for (auto it = ngrams.begin(); it != ngrams.end(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (ngrams.size() > 0) {
    vec.mul(1.0 / ngrams.size());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rsi
movq %rsp, %rdi
callq 0x65be
movq %rbx, %rdi
callq 0xf1e8
movq (%rsp), %r14
cmpq 0x8(%rsp), %r14
je 0x11d09
movq %r14, %r12
negq %r12
movq 0x20(%r15), %rsi
movslq (%r14), %rdx
movq %rbx, %rdi
callq 0xf302
addq $0x4, %r14
addq $-0x4, %r12
cmpq 0x8(%rsp), %r14
jne 0x11c96
movq (%rsp), %rax
cmpq %rax, %r14
je 0x11d06
addq %r12, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xcc3c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcc44(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xcc08(%rip), %xmm0     # 0x1e8f8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf238
movq (%rsp), %r14
jmp 0x11d09
movq %rax, %r14
testq %r14, %r14
je 0x11d1e
movq 0x10(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x4300
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x11d2c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x11d45
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::checkModel(std::istream&)
bool FastText::checkModel(std::istream& in) {
  int32_t magic;
  int32_t version;
  in.read((char*)&(magic), sizeof(int32_t));
  if (magic != FASTTEXT_FILEFORMAT_MAGIC_INT32) {
    return false;
  }
  in.read((char*)&(version), sizeof(int32_t));
  if (version != FASTTEXT_VERSION) {
    return false;
  }
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x43b0
cmpl $0x2f4f16ba, (%r14)     # imm = 0x2F4F16BA
jne 0x12837
movq %rsp, %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43b0
cmpl $0xb, (%r14)
sete %al
jmp 0x12839
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveDict()
void FastText::saveDict() {
  std::string fn(args_->output);
  std::ofstream ofs(fn, std::ofstream::binary);
  if (!ofs.is_open()) {
    std::cerr << "Model file cannot be opened for saving!" << std::endl;
    exit(EXIT_FAILURE);
  }
  args_->save(ofs);
  dict_->save(ofs);
  ofs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0xa910
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x4630
leaq 0x90(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12952
movq (%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5f4c
movq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x87f2
leaq 0x20(%rsp), %rdi
callq 0x4440
movq 0x176a4(%rip), %rax     # 0x29fa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x4280
leaq 0x118(%rsp), %rdi
callq 0x4110
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12945
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq 0x17697(%rip), %rdi     # 0x29ff0
leaq 0xce02(%rip), %rsi      # 0x1f762
movl $0x27, %edx
callq 0x4350
movq 0x1767f(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
jmp 0x12992
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4480
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x129a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::loadDict(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FastText::loadDict(const std::string& filename) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (!checkModel(ifs)) {
    std::cerr << "Model file has wrong file format!" << std::endl;
    exit(EXIT_FAILURE);
  }
  loadDict(ifs);
  ifs.close();
}

// Assembly:
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x44f0
leaq 0x80(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12a13
leaq 0x8(%rsp), %rsi
callq 0x127f6
testb %al, %al
je 0x12a39
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a7c
leaq 0x8(%rsp), %rdi
callq 0x4090
leaq 0x8(%rsp), %rdi
callq 0x40c0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq 0x175d6(%rip), %rdi     # 0x29ff0
leaq 0xcd69(%rip), %rsi      # 0x1f78a
movl $0x28, %edx
callq 0x4350
movq 0x175be(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x12a5d
movq 0x175b0(%rip), %rdi     # 0x29ff0
leaq 0xcd6c(%rip), %rsi      # 0x1f7b3
movl $0x21, %edx
callq 0x4350
movq 0x17598(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::loadDict(std::istream&)
void FastText::loadDict(std::istream& in) {
  args_ = std::make_shared<Args>();
  dict_ = std::make_shared<Dictionary>(args_);

  args_->load(in);
  dict_->load(in);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x1a31a
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x8(%r14), %rdi
movups %xmm0, (%r14)
testq %rdi, %rdi
je 0x12ad6
callq 0xa8a0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12ad6
callq 0xa8a0
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x1a488
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%r14), %rdi
movups %xmm0, 0x10(%r14)
testq %rdi, %rdi
je 0x12b25
callq 0xa8a0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12b25
callq 0xa8a0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6064
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x89e6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveModel()
void FastText::saveModel() {
  std::string fn(args_->output);
  if (quant_) {
    fn += ".ftz";
  } else {
    fn += ".bin";
  }
  std::ofstream ofs(fn, std::ofstream::binary);
  if (!ofs.is_open()) {
    std::cerr << "Model file cannot be opened for saving!" << std::endl;
    exit(EXIT_FAILURE);
  }
  signModel(ofs);
  args_->save(ofs);
  dict_->save(ofs);

  ofs.write((char*)&(quant_), sizeof(bool));
  if (quant_) {
    qinput_->save(ofs);
  } else {
    input_->save(ofs);
  }

  ofs.write((char*)&(args_->qout), sizeof(bool));
  if (quant_ && args_->qout) {
    qoutput_->save(ofs);
  } else {
    output_->save(ofs);
  }

  ofs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xa910
leaq 0xcc55(%rip), %rax      # 0x1f7d5
leaq 0xcc53(%rip), %rsi      # 0x1f7da
cmpb $0x0, 0x80(%rbx)
cmovneq %rax, %rsi
movq %r14, %rdi
callq 0x4620
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x4630
leaq 0xa0(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12cf8
leaq 0xc(%rsp), %rsi
movl $0x2f4f16ba, (%rsi)     # imm = 0x2F4F16BA
movl $0xb, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x43f0
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x43f0
movq (%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5f4c
movq 0x10(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x87f2
leaq 0x80(%rbx), %r14
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x43f0
cmpb $0x1, (%r14)
jne 0x12c43
movq 0x40(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xef74
jmp 0x12c51
movq 0x20(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe53c
movl $0x12c, %esi            # imm = 0x12C
addq (%rbx), %rsi
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x43f0
cmpb $0x1, (%r14)
jne 0x12c8a
movq (%rbx), %rax
cmpb $0x1, 0x12c(%rax)
jne 0x12c8a
movq 0x50(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xef74
jmp 0x12c98
movq 0x30(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe53c
leaq 0x30(%rsp), %rdi
callq 0x4440
movq 0x172ff(%rip), %rax     # 0x29fa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x30(%rsp,%rcx)
callq 0x4280
leaq 0x128(%rsp), %rdi
callq 0x4110
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12ceb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq 0x172f1(%rip), %rdi     # 0x29ff0
leaq 0xca5c(%rip), %rsi      # 0x1f762
movl $0x27, %edx
callq 0x4350
movq 0x172d9(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
jmp 0x12d28
movq %rax, %rbx
jmp 0x12d3a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4480
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12d51
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, int)
void FastText::loadModel(const std::string& filename,
                         const bool inference_mode /* = false */,
                         const int timeout_sec /* = -1 */) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (!checkModel(ifs)) {
    std::cerr << "Model file has wrong file format!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (inference_mode) {
    loadModelForInference(ifs, filename, timeout_sec);
  } else {
    loadModel(ifs);
  }
  ifs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdi
movl $0x4, %edx
callq 0x44f0
leaq 0x78(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x1322c
movq %rsp, %rsi
callq 0x127f6
testb %al, %al
je 0x13252
testb %bpl, %bpl
je 0x13203
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x13294
jmp 0x1320e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x13704
movq %rsp, %rdi
callq 0x4090
movq %rsp, %rdi
callq 0x40c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x16dbd(%rip), %rdi     # 0x29ff0
leaq 0xc550(%rip), %rsi      # 0x1f78a
movl $0x28, %edx
callq 0x4350
movq 0x16da5(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x13276
movq 0x16d97(%rip), %rdi     # 0x29ff0
leaq 0xc553(%rip), %rsi      # 0x1f7b3
movl $0x21, %edx
callq 0x4350
movq 0x16d7f(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::supervised(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
void FastText::supervised(Model& model, real lr,
                          const std::vector<int32_t>& line,
                          const std::vector<int32_t>& labels) {
  if (labels.size() == 0 || line.size() == 0) return;
  std::uniform_int_distribution<> uniform(0, labels.size() - 1);
  int32_t i = uniform(model.rng);
  model.update(line, labels[i], lr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
je 0x144a1
movq %rdx, %rbx
movq 0x8(%rdx), %rcx
cmpq (%rdx), %rcx
je 0x144a1
movq %rsi, %r14
shrq $0x2, %rax
decl %eax
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
movl %eax, 0x4(%rdi)
addq $0x110, %rsi            # imm = 0x110
movq %rdi, %rdx
movss %xmm0, 0x4(%rsp)
callq 0xc07c
cltq
movq (%r15), %rcx
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %rbx, %rsi
movss 0x4(%rsp), %xmm0
callq 0x10618
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::cbow(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::cbow(Model& model, real lr,
                    const std::vector<int32_t>& line) {
  std::vector<int32_t> bow;
  std::uniform_int_distribution<> uniform(1, args_->ws);
  for (int32_t w = 0; w < line.size(); w++) {
    int32_t boundary = uniform(model.rng);
    bow.clear();
    for (int32_t c = -boundary; c <= boundary; c++) {
      if (c != 0 && w + c >= 0 && w + c < line.size()) {
        const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w + c]);
        bow.insert(bow.end(), ngrams.cbegin(), ngrams.cend());
      }
    }
    model.update(bow, line[w], lr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movss %xmm0, 0x24(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq (%rdi), %rax
movl 0x98(%rax), %eax
movl $0x1, 0x28(%rsp)
movl %eax, 0x2c(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0x14a80
movq %rdx, %rbx
leaq 0x110(%rsi), %rax
movq %rax, 0x38(%rsp)
xorl %r12d, %r12d
movq %rsi, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rdi, %rdx
callq 0xc07c
movl %eax, %r14d
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x149d5
movq %rax, 0x8(%rsp)
testl %r14d, %r14d
js 0x14a39
leal 0x1(,%r14,2), %r13d
movl %r12d, %ebp
subl %r14d, %ebp
xorl %r15d, %r15d
cmpl %r15d, %r14d
je 0x14a31
movl %ebp, %eax
addl %r15d, %eax
js 0x14a31
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x14a31
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rdi
movl (%rcx,%rax,4), %esi
callq 0x6562
movq 0x8(%rsp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rsp, %rdi
callq 0x1ad16
incl %r15d
cmpl %r15d, %r13d
jne 0x149eb
movq (%rbx), %rax
movl (%rax,%r12,4), %edx
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
movss 0x24(%rsp), %xmm0
callq 0x10618
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x149b0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14a80
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14a93
jmp 0x14a93
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14aac
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::predict(std::istream&, int, bool)
void FastText::predict(std::istream& in, int32_t k, bool print_prob) {
  std::vector<std::pair<real,std::string>> predictions;
  while (in.peek() != EOF) {
    predict(in, k, predictions);
    if (predictions.empty()) {
      std::cout << std::endl;
      continue;
    }
    for (auto it = predictions.cbegin(); it != predictions.cend(); it++) {
      if (it != predictions.cbegin()) {
        std::cout << " ";
      }
      std::cout << it->second;
      if (print_prob) {
        std::cout << " " << exp(it->first);
      }
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x149ac(%rip), %r13     # 0x29fc0
leaq 0x9547(%rip), %r12      # 0x1eb62
movq %r14, %rdi
callq 0x4130
cmpl $-0x1, %eax
je 0x156d0
movq %r15, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x15326
movq 0x10(%rsp), %rbp
cmpq 0x18(%rsp), %rbp
je 0x156a3
cmpq 0x10(%rsp), %rbp
je 0x15663
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4350
movq 0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq %r13, %rdi
callq 0x4350
testb %bl, %bl
je 0x1569d
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4350
movss (%rbp), %xmm0
callq 0x4530
cvtss2sd %xmm0, %xmm0
movq %r13, %rdi
callq 0x44e0
addq $0x28, %rbp
jmp 0x15645
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
jmp 0x1561b
leaq 0x10(%rsp), %rdi
callq 0x1a140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x156eb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a140
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::wordVectors()
void FastText::wordVectors() {
  std::string word;
  Vector vec(args_->dim);
  while (std::cin >> word) {
    getVector(vec, word);
    std::cout << word << " " << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0xf1ac
movq 0x14898(%rip), %r14     # 0x29fd8
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x9411(%rip), %rbp      # 0x1eb62
movq %r14, %rdi
movq %r15, %rsi
callq 0x43d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x157db
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11c60
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x14837(%rip), %rdi     # 0x29fc0
callq 0x4350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4350
movq %r13, %rdi
movq %r12, %rsi
callq 0xf605
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
jmp 0x15751
leaq 0x28(%rsp), %rdi
callq 0xf1d6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15801
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x15822
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf1d6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1583e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::ngramVectors(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FastText::ngramVectors(std::string word) {
  std::vector<int32_t> ngrams;
  std::vector<std::string> substrings;
  Vector vec(args_->dim);
  dict_->getNgrams(word, ngrams, substrings);
  for (int32_t i = 0; i < ngrams.size(); i++) {
    vec.zero();
    if (ngrams[i] >= 0) {
      vec.addRow(*input_, ngrams[i]);
    }
    std::cout << substrings[i] << " " << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0xf1ac
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rsi
callq 0x68f8
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x15c15
movl $0x8, %ebp
xorl %r15d, %r15d
leaq 0x38(%rsp), %r14
leaq 0x8fed(%rip), %r12      # 0x1eb62
movq %r14, %rdi
callq 0xf1e8
movq (%rsp), %rax
movslq (%rax,%r15,4), %rdx
testq %rdx, %rdx
js 0x15b96
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xf302
movq 0x20(%rsp), %rax
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq 0x14415(%rip), %rdi     # 0x29fc0
callq 0x4350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4350
movq %r13, %rdi
movq %r14, %rsi
callq 0xf605
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
movq 0x8(%rsp), %rax
subq (%rsp), %rax
incq %r15
sarq $0x2, %rax
addq $0x20, %rbp
cmpq %r15, %rax
ja 0x15b75
leaq 0x38(%rsp), %rdi
callq 0xf1d6
leaq 0x20(%rsp), %rdi
callq 0xa678
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15c3f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c55
movq %rax, %rbx
jmp 0x15c62
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf1d6
leaq 0x20(%rsp), %rdi
callq 0xa678
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15c82
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0