LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rsi
movq %r8, %rdx
callq 0xdb36
movslq %ebp, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x88(%r15), %rax
cmpq %rax, %rbp
jge 0xe20d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jne 0xe178
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xd452
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss 0xd024(%rip), %xmm1     # 0x1b170
ja 0xe168
mulss 0xd30a(%rip), %xmm1     # 0x1b460
cvttss2si %xmm1, %eax
movq 0xa0(%r15), %rcx
cltq
movss (%rcx,%rax,4), %xmm0
movq (%r14), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
ja 0xe1f8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xd452
movss (%rax), %xmm0
ucomiss 0xcfe2(%rip), %xmm0     # 0x1b170
jbe 0xe194
xorl %eax, %eax
jmp 0xe1ac
mulss 0xd2c4(%rip), %xmm0     # 0x1b460
cvttss2si %xmm0, %eax
movq 0xa0(%r15), %rcx
cltq
movl (%rcx,%rax,4), %eax
addq %r13, %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0xef42
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq -0x37e(%rip), %rdx      # 0xde4e
callq 0xea28
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0xe1f8
leaq -0x3a0(%rip), %rdx      # 0xde4e
callq 0xea46
addq $-0x8, 0x8(%r14)
incq %rbp
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
jmp 0xe113
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe353
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x88(%rdi)
jle 0xe372
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xe346
movss %xmm0, 0xc(%rsp)
leaq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdd72
movq 0x40(%r14), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0xe29a
cmpl $0x2, %eax
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
jne 0xe2ac
callq 0xd9e0
jmp 0xe2b1
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xda92
jmp 0xe2b1
callq 0xdc7a
addss 0x8c(%r14), %xmm0
movss %xmm0, 0x8c(%r14)
incq 0x90(%r14)
movq 0x40(%r14), %rax
cmpl $0x4, 0xc0(%rax)
jne 0xe31c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xc621(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xc629(%rip), %xmm0     # 0x1a920
leaq 0x70(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xc5d9(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xd0cc
movq (%rbx), %r12
leaq 0x70(%r14), %r15
cmpq 0x8(%rbx), %r12
je 0xe346
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0xce35(%rip), %xmm0     # 0x1b170
callq 0xc01c
addq $0x4, %r12
jmp 0xe323
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd261(%rip), %rdi      # 0x1b5bb
leaq 0xd16d(%rip), %rsi      # 0x1b4ce
leaq 0xd25f(%rip), %rcx      # 0x1b5c7
movl $0xcc, %edx
callq 0x4210
leaq 0xd298(%rip), %rdi      # 0x1b611
leaq 0xd14e(%rip), %rsi      # 0x1b4ce
leaq 0xd240(%rip), %rcx      # 0x1b5c7
movl $0xcd, %edx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe48b
movl %edx, %r12d
movq %rdi, %r15
cmpl %edx, 0x88(%rdi)
jle 0xe4aa
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xe47c
movl %r8d, %ebx
movl %ecx, %ebp
movss %xmm0, (%rsp)
leaq 0x50(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xdd72
movq 0x40(%r15), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0xe40c
cmpl $0x2, %eax
movss (%rsp), %xmm0
movq %r15, %rdi
movl %r12d, %esi
jne 0xe41e
callq 0xd9e0
jmp 0xe423
movq %r15, %rdi
movl %r12d, %esi
movss (%rsp), %xmm0
callq 0xda92
jmp 0xe423
callq 0xdc7a
addss 0x8c(%r15), %xmm0
movss %xmm0, 0x8c(%r15)
incq 0x90(%r15)
movq (%r14), %r13
leaq 0x70(%r15), %r12
cmpq 0x8(%r14), %r13
je 0xe47c
movslq (%r13), %rdx
movss 0x4(%rsp), %xmm0
cmpl %ebx, %edx
jl 0xe45f
movss 0xcd11(%rip), %xmm0     # 0x1b170
cmpl %ebp, %edx
jg 0xe46b
movss 0xcd05(%rip), %xmm0     # 0x1b170
movq (%r15), %rdi
movq %r12, %rsi
callq 0xc01c
addq $0x4, %r13
jmp 0xe443
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd129(%rip), %rdi      # 0x1b5bb
leaq 0xd035(%rip), %rsi      # 0x1b4ce
leaq 0xd17f(%rip), %rcx      # 0x1b61f
movl $0xe2, %edx
callq 0x4210
leaq 0xd160(%rip), %rdi      # 0x1b611
leaq 0xd016(%rip), %rsi      # 0x1b4ce
leaq 0xd160(%rip), %rcx      # 0x1b61f
movl $0xe3, %edx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movapd 0xcf16(%rip), %xmm3     # 0x1b490
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r15
jae 0xe5d0
cvtsi2sdq (%rax,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jb 0xe5a2
sqrtsd %xmm0, %xmm0
jmp 0xe5b3
callq 0x42a0
movapd 0xcee1(%rip), %xmm3     # 0x1b490
xorpd %xmm2, %xmm2
andpd %xmm3, %xmm0
cvtss2sd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
incq %r15
jmp 0xe57a
leaq 0xa8(%rbx), %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0xe67b
cvtsi2sdq (%rax,%r13,8), %xmm0
ucomisd 0xceb3(%rip), %xmm0     # 0x1b4b0
jb 0xe605
sqrtsd %xmm0, %xmm0
jmp 0xe60a
callq 0x42a0
cvtsd2ss %xmm0, %xmm0
andps 0xce6b(%rip), %xmm0     # 0x1b480
mulss 0xce53(%rip), %xmm0     # 0x1b470
divss 0x8(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
testq %rbp, %rbp
js 0xe636
cvtsi2ss %rbp, %xmm0
jmp 0xe64d
movq %rbp, %rax
shrq %rax
movl %ebp, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movaps 0x10(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0xe66c
movl %r13d, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9292
incq %rbp
jmp 0xe62a
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
jmp 0xe5df
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rsi
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdx
callq 0xbafd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/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, %r14
movq 0x10(%rdi), %rsi
movq %rsp, %rdi
callq 0x5e96
movq %rbx, %rdi
callq 0xd078
movq (%rsp), %r12
movq %r12, %r15
negq %r15
cmpq 0x8(%rsp), %r12
je 0xf9d8
movq 0x20(%r14), %rsi
movslq (%r12), %rdx
movq %rbx, %rdi
callq 0xd19e
addq $0x4, %r12
addq $-0x4, %r15
jmp 0xf9b7
movq (%rsp), %rax
cmpq %rax, %r12
je 0xfa24
addq %r15, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xaf18(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xaf20(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xaed4(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0xd0cc
movq %rsp, %rdi
callq 0x8c0e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xfa3a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveVectors()
void FastText::saveVectors() {
  std::ofstream ofs(args_->output + ".vec");
  if (!ofs.is_open()) {
    std::cerr << "Error opening file for saving vectors." << std::endl;
    exit(EXIT_FAILURE);
  }
  ofs << dict_->nwords() << " " << args_->dim << std::endl;
  Vector vec(args_->dim);
  for (int32_t i = 0; i < dict_->nwords(); i++) {
    std::string word = dict_->getWord(i);
    getVector_ckpt(vec, i);
    ofs << word << " " << vec << std::endl;
  }
  ofs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0xbcdd(%rip), %rdx      # 0x1b74d
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xc742
leaq 0x38(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x4650
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0xa8(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0xfba2
movq 0x10(%rbx), %rdi
callq 0x5e34
leaq 0x38(%rsp), %rdi
movl %eax, %esi
callq 0x45b0
leaq 0xb0a1(%rip), %rsi      # 0x1ab69
movq %rax, %rdi
callq 0x4330
movq (%rbx), %rcx
movl 0x94(%rcx), %esi
movq %rax, %rdi
callq 0x45b0
movq %rax, %rdi
callq 0x4190
movq (%rbx), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd03c
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0xb054(%rip), %r13      # 0x1ab69
movq 0x10(%rbx), %rdi
callq 0x5e34
cmpl %eax, %ebp
jge 0xfb72
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x63b2
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xfc0e
movq %r12, %rdi
movq %r14, %rsi
callq 0x42f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x4330
movq %rax, %rdi
movq %r15, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
movq %r14, %rdi
callq 0x46c8
incl %ebp
jmp 0xfb15
leaq 0x38(%rsp), %rdi
callq 0x4490
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x38(%rsp), %rdi
callq 0x44c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18447(%rip), %rdi     # 0x27ff0
leaq 0xbb6c(%rip), %rsi      # 0x1b71c
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0xfbdf
jmp 0xfbd8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
jmp 0xfc05
movq %rax, %rbx
jmp 0xfbfb
jmp 0xfbdf
movq %rax, %rbx
jmp 0xfbf1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x38(%rsp), %rdi
callq 0x44c0
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveVectors(int)
void FastText::saveVectors(int32_t checkpoint) {
  std::ofstream ofs(args_->output + "_Chk" + std::to_string(checkpoint) + ".ckpt.vec");
  if (!ofs.is_open()) {
    std::cerr << "Error opening file for saving vectors." << std::endl;
    exit(EXIT_FAILURE);
  }
  ofs << dict_->nwords() << " " << args_->dim << std::endl;
  Vector vec(args_->dim);
  for (int32_t i = 0; i < dict_->nwords(); i++) {
    std::string word = dict_->getWord(i);
    getVector_ckpt(vec, i);
    ofs << word << " " << vec << std::endl;
  }
  ofs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0xbadd(%rip), %rdx      # 0x1b743
leaq 0x68(%rsp), %rdi
callq 0xc742
leaq 0x48(%rsp), %rdi
movl %ebp, %esi
callq 0x15b33
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x15acc
leaq 0xbab1(%rip), %rdx      # 0x1b748
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15aad
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x4650
leaq 0x28(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x48(%rsp), %rdi
callq 0x46c8
leaq 0x68(%rsp), %rdi
callq 0x46c8
leaq 0xf8(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0xfdfa
movq 0x10(%rbx), %rdi
callq 0x5e34
leaq 0x88(%rsp), %rdi
movl %eax, %esi
callq 0x45b0
leaq 0xae52(%rip), %rsi      # 0x1ab69
movq %rax, %rdi
callq 0x4330
movq (%rbx), %rcx
movl 0x94(%rcx), %esi
movq %rax, %rdi
callq 0x45b0
movq %rax, %rdi
callq 0x4190
movq (%rbx), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd03c
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x88(%rsp), %r12
leaq 0xae02(%rip), %r13      # 0x1ab69
movq 0x10(%rbx), %rdi
callq 0x5e34
cmpl %eax, %ebp
jge 0xfdc4
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x63b2
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xfc0e
movq %r12, %rdi
movq %r14, %rsi
callq 0x42f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x4330
movq %rax, %rdi
movq %r15, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
movq %r14, %rdi
callq 0x46c8
incl %ebp
jmp 0xfd67
leaq 0x88(%rsp), %rdi
callq 0x4490
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x88(%rsp), %rdi
callq 0x44c0
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x181ef(%rip), %rdi     # 0x27ff0
leaq 0xb914(%rip), %rsi      # 0x1b71c
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0xfe64
jmp 0xfe5d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x46c8
jmp 0xfe33
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0xfe42
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46c8
jmp 0xfe51
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x46c8
jmp 0xfe8d
movq %rax, %rbx
jmp 0xfe80
jmp 0xfe64
movq %rax, %rbx
jmp 0xfe76
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x88(%rsp), %rdi
callq 0x44c0
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveOutput()
void FastText::saveOutput() {
  std::ofstream ofs(args_->output + ".output");
  if (!ofs.is_open()) {
    std::cerr << "Error opening file for saving vectors." << std::endl;
    exit(EXIT_FAILURE);
  }
  ofs << dict_->nwords() << " " << args_->dim << std::endl;
  Vector vec(args_->dim);
  for (int32_t i = 0; i < dict_->nwords(); i++) {
    std::string word = dict_->getWord(i);
    vec.zero();
    vec.addRow(*output_, i);
    ofs << word << " " << vec << std::endl;
  }
  ofs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0xb89a(%rip), %rdx      # 0x1b752
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xc742
leaq 0x38(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x4650
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0xa8(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0xfffa
movq 0x10(%rbx), %rdi
callq 0x5e34
leaq 0x38(%rsp), %rdi
movl %eax, %esi
callq 0x45b0
leaq 0xac59(%rip), %rsi      # 0x1ab69
movq %rax, %rdi
callq 0x4330
movq (%rbx), %rcx
movl 0x94(%rcx), %esi
movq %rax, %rdi
callq 0x45b0
movq %rax, %rdi
callq 0x4190
movq (%rbx), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd03c
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0xac0b(%rip), %rbp      # 0x1ab69
movq 0x10(%rbx), %rdi
callq 0x5e34
cltq
cmpq %rax, %r14
jge 0xffca
movq 0x10(%rbx), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x63b2
movq %r12, %rdi
callq 0xd078
movq 0x30(%rbx), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xd19e
movq %r13, %rdi
movq %r15, %rsi
callq 0x42f0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4330
movq %rax, %rdi
movq %r12, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
movq %r15, %rdi
callq 0x46c8
incq %r14
jmp 0xff5e
leaq 0x38(%rsp), %rdi
callq 0x4490
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x38(%rsp), %rdi
callq 0x44c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x17fef(%rip), %rdi     # 0x27ff0
leaq 0xb714(%rip), %rsi      # 0x1b71c
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x10037
jmp 0x10030
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
jmp 0x1005d
movq %rax, %rbx
jmp 0x10053
jmp 0x10037
movq %rax, %rbx
jmp 0x10049
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x38(%rsp), %rdi
callq 0x44c0
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x43e0
cmpl $0x2f4f16ba, (%r14)     # imm = 0x2F4F16BA
jne 0x100a3
movq %rsp, %r14
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43e0
cmpl $0xb, (%r14)
sete %al
jmp 0x100a5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::signModel(std::ostream&)
void FastText::signModel(std::ostream& out) {
  const int32_t magic = FASTTEXT_FILEFORMAT_MAGIC_INT32;
  const int32_t version = FASTTEXT_VERSION;
  out.write((char*)&(magic), sizeof(int32_t));
  out.write((char*)&(version), sizeof(int32_t));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x2f4f16ba, (%rsi)     # imm = 0x2F4F16BA
leaq 0x8(%rsp), %r14
movl $0xb, (%r14)
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4430
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4460
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x4650
leaq 0x98(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x1017e
movq (%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5960
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x76fe
leaq 0x28(%rsp), %rdi
callq 0x4490
leaq 0x28(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rdi
callq 0x46c8
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq 0x17e6b(%rip), %rdi     # 0x27ff0
leaq 0xb5ce(%rip), %rsi      # 0x1b75a
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
movq %rax, %rbx
jmp 0x101b3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rdx
callq 0x4520
leaq 0x80(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x10227
leaq 0x8(%rsp), %rsi
callq 0x10066
testb %al, %al
je 0x10244
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1027c
leaq 0x8(%rsp), %rdi
callq 0x40a0
leaq 0x8(%rsp), %rdi
callq 0x40e0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq 0x17dc2(%rip), %rdi     # 0x27ff0
leaq 0xb54d(%rip), %rsi      # 0x1b782
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x1025f
movq 0x17da5(%rip), %rdi     # 0x27ff0
leaq 0xb559(%rip), %rsi      # 0x1b7ab
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x15b8c
movq %r14, %rdi
movq %r15, %rsi
callq 0x160b4
leaq 0x8(%rsp), %rdi
callq 0x8b66
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x15ba7
leaq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x162fc
leaq 0x8(%rsp), %rdi
callq 0x8b66
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x5a62
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7836
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4460
leaq 0xb4b5(%rip), %rax      # 0x1b7cd
leaq 0xb4b3(%rip), %rsi      # 0x1b7d2
cmpb $0x0, 0x80(%rbx)
cmovneq %rax, %rsi
movq %r14, %rdi
callq 0x4630
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x4650
leaq 0x98(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x10427
leaq 0x28(%rsp), %rsi
callq 0x100ae
movq (%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5960
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x76fe
leaq 0x80(%rbx), %r14
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x4430
cmpb $0x1, (%r14)
jne 0x103ab
movq 0x40(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0xcdfc
jmp 0x103b9
movq 0x20(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc33a
movl $0x12c, %esi            # imm = 0x12C
addq (%rbx), %rsi
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x4430
cmpb $0x1, (%r14)
jne 0x103f0
movq (%rbx), %rax
cmpb $0x1, 0x12c(%rax)
jne 0x103f0
movq 0x50(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0xcdfc
jmp 0x103fe
movq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc33a
leaq 0x28(%rsp), %rdi
callq 0x4490
leaq 0x28(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rdi
callq 0x46c8
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq 0x17bc2(%rip), %rdi     # 0x27ff0
leaq 0xb325(%rip), %rsi      # 0x1b75a
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x1044c
movq %rax, %rbx
jmp 0x1045e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::saveModel(int)
void FastText::saveModel(int32_t checkpoint) {
  std::string fn(args_->output + "_Chk" + std::to_string(checkpoint) + ".ckpt");
  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 %rbp
pushq %r14
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x40, %rsi
leaq 0xb2b5(%rip), %rdx      # 0x1b743
leaq 0x40(%rsp), %rdi
callq 0xc742
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x15b33
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x15acc
leaq 0xb318(%rip), %rdx      # 0x1b7d7
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0x15aad
leaq 0x60(%rsp), %rdi
callq 0x46c8
leaq 0x20(%rsp), %rdi
callq 0x46c8
leaq 0x40(%rsp), %rdi
callq 0x46c8
leaq 0xb2dc(%rip), %rax      # 0x1b7cd
leaq 0xb2da(%rip), %rsi      # 0x1b7d2
cmpb $0x0, 0x80(%rbx)
cmovneq %rax, %rsi
movq %rsp, %rdi
callq 0x4630
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
pushq $0x4
popq %rdx
callq 0x4650
leaq 0xd0(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x105fd
leaq 0x60(%rsp), %rsi
callq 0x100ae
movq (%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x5960
movq 0x10(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x76fe
leaq 0x80(%rbx), %r14
leaq 0x60(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x4430
cmpb $0x1, (%r14)
jne 0x10582
movq 0x40(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0xcdfc
jmp 0x10590
movq 0x20(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0xc33a
movl $0x12c, %esi            # imm = 0x12C
addq (%rbx), %rsi
leaq 0x60(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x4430
cmpb $0x1, (%r14)
jne 0x105c7
movq (%rbx), %rax
cmpb $0x1, 0x12c(%rax)
jne 0x105c7
movq 0x50(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0xcdfc
jmp 0x105d5
movq 0x30(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0xc33a
leaq 0x60(%rsp), %rdi
callq 0x4490
leaq 0x60(%rsp), %rdi
callq 0x44c0
movq %rsp, %rdi
callq 0x46c8
addq $0x260, %rsp            # imm = 0x260
popq %rbx
popq %r14
popq %rbp
retq
movq 0x179ec(%rip), %rdi     # 0x27ff0
leaq 0xb14f(%rip), %rsi      # 0x1b75a
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x10622
movq %rax, %rbx
jmp 0x1065c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x46c8
jmp 0x10639
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x46c8
jmp 0x10648
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x1065f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x44c0
movq %rsp, %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rdx
callq 0x4520
leaq 0x78(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x106e8
movq %rsp, %rsi
callq 0x10066
testb %al, %al
je 0x10705
testb %bpl, %bpl
je 0x106bf
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x1073c
jmp 0x106ca
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1098c
movq %rsp, %rdi
callq 0x40a0
movq %rsp, %rdi
callq 0x40e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x17901(%rip), %rdi     # 0x27ff0
leaq 0xb08c(%rip), %rsi      # 0x1b782
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x10720
movq 0x178e4(%rip), %rdi     # 0x27ff0
leaq 0xb098(%rip), %rsi      # 0x1b7ab
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::printInfo(float, float)
void FastText::printInfo(real progress, real loss) {
  real t = real(clock() - start) / CLOCKS_PER_SEC;
  real wst = real(tokenCount) / t;
  real lr = args_->lr * (1.0 - progress);
  int eta = int(t / progress * (1 - progress) / args_->thread);
  int etah = eta / 3600;
  int etam = (eta - etah * 3600) / 60;
  std::cerr << std::fixed;
  std::cerr << "\rProgress: " << std::setprecision(1) << 100 * progress << "%";
  std::cerr << "  words/sec/thread: " << std::setprecision(0) << wst;
  std::cerr << "  lr: " << std::setprecision(6) << lr;
  std::cerr << "  loss: " << std::setprecision(6) << loss;
  std::cerr << "  eta: " << etah << "h" << etam << "m ";
  std::cerr << std::flush;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm1, 0x14(%rsp)
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x4220
subq 0x78(%rbx), %rax
cvtsi2ss %rax, %xmm0
divss 0xaabf(%rip), %xmm0     # 0x1b710
movq 0x70(%rbx), %rax
cvtsi2ss %rax, %xmm3
movq (%rbx), %rax
movss 0x8(%rsp), %xmm4
cvtss2sd %xmm4, %xmm1
movsd 0x9c79(%rip), %xmm2     # 0x1a8e8
subsd %xmm1, %xmm2
mulsd 0x80(%rax), %xmm2
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0x10(%rsp)
divss %xmm0, %xmm3
movss %xmm3, 0xc(%rsp)
divss %xmm4, %xmm0
movss 0xa4d5(%rip), %xmm1     # 0x1b170
subss %xmm4, %xmm1
mulss %xmm0, %xmm1
cvtsi2ssl 0xd4(%rax), %xmm0
divss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movl $0xe10, %esi            # imm = 0xE10
movl %ecx, %eax
cltd
idivl %esi
movl %eax, %r14d
imull $0xfffff1f0, %eax, %eax # imm = 0xFFFFF1F0
addl %ecx, %eax
pushq $0x3c
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
movq 0x17319(%rip), %rbx     # 0x27ff0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0xaafb(%rip), %rsi      # 0x1b7f0
movq %rbx, %rdi
callq 0x4330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x1, 0x8(%rax,%rcx)
movss 0x8(%rsp), %xmm0
mulss 0xa9f9(%rip), %xmm0     # 0x1b714
movq %rax, %rdi
callq 0x4270
leaq 0xaad2(%rip), %rsi      # 0x1b7fc
movq %rax, %rdi
callq 0x4330
leaq 0xaac5(%rip), %rsi      # 0x1b7fe
movq %rbx, %rdi
callq 0x4330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andq $0x0, 0x8(%rax,%rcx)
movq %rax, %rdi
movss 0xc(%rsp), %xmm0
callq 0x4270
leaq 0xaab0(%rip), %rsi      # 0x1b813
movq %rbx, %rdi
callq 0x4330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x6
popq %r15
movq %r15, 0x8(%rax,%rcx)
movq %rax, %rdi
movss 0x10(%rsp), %xmm0
callq 0x4270
leaq 0xaa8a(%rip), %rsi      # 0x1b81a
movq %rbx, %rdi
callq 0x4330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x8(%rax,%rcx)
movq %rax, %rdi
movss 0x14(%rsp), %xmm0
callq 0x4270
leaq 0xaa6a(%rip), %rsi      # 0x1b823
movq %rbx, %rdi
callq 0x4330
movq %rax, %rdi
movl %r14d, %esi
callq 0x45b0
leaq 0x931c(%rip), %rsi      # 0x1a0ef
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
movl %ebp, %esi
callq 0x45b0
leaq 0xaa3f(%rip), %rsi      # 0x1b82b
movq %rax, %rdi
callq 0x4330
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::selectEmbeddings(int) const
std::vector<int32_t> FastText::selectEmbeddings(int32_t cutoff) const {
  Vector norms(input_->m_);
  input_->l2NormRow(norms);
  std::vector<int32_t> idx(input_->m_, 0);
  std::iota(idx.begin(), idx.end(), 0);
  auto eosid = dict_->getId(Dictionary::EOS);
  std::sort(idx.begin(), idx.end(),
      [&norms, eosid] (size_t i1, size_t i2) {
      return eosid ==i1 || (eosid != i2 && norms[i1] > norms[i2]);
      });
  idx.erase(idx.begin() + cutoff, idx.end());
  return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x8(%rax), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xd03c
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xc2be
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
leaq 0x24(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x8676
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
je 0x10e72
movl %edx, (%rax)
incl %edx
addq $0x4, %rax
jmp 0x10e63
movq 0x10(%r14), %rdi
leaq 0x1750b(%rip), %rsi     # 0x28388
callq 0x5f5e
movq (%rbx), %r12
movq 0x8(%rbx), %r15
cmpq %r15, %r12
je 0x10f0d
movl %eax, %r14d
movq %r15, %r13
subq %r12, %r13
movq %r13, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %r8d
callq 0x15508
cmpq $0x41, %r13
jl 0x10efa
leaq 0x40(%r12), %r13
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %ecx
callq 0x1589b
leaq 0x10(%rsp), %r12
cmpq %r15, %r13
je 0x10f0d
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x15932
addq $0x4, %r13
jmp 0x10ee1
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x1589b
movslq %ebp, %rsi
shlq $0x2, %rsi
addq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
callq 0x15c46
leaq 0x10(%rsp), %rdi
callq 0xd066
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10f4a
jmp 0x10f43
movq %rax, %r14
jmp 0x10f55
jmp 0x10f4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c0e
leaq 0x10(%rsp), %rdi
callq 0xd066
movq %r14, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11369
movq %rdx, %rbx
movq 0x8(%rdx), %rcx
cmpq (%rdx), %rcx
je 0x11369
movq %rsi, %r14
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
shrq $0x2, %rax
decl %eax
movl %eax, 0x4(%rdi)
addq $0x110, %rsi            # imm = 0x110
movss %xmm0, 0x4(%rsp)
callq 0x892c
cltq
movq (%r15), %rcx
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %rbx, %rsi
movss 0x4(%rsp), %xmm0
callq 0xe22a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rbx
movss %xmm0, 0xc(%rsp)
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
movq (%rdi), %rax
movl 0x98(%rax), %eax
leaq 0x40(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, 0x4(%rcx)
movq %rsi, 0x30(%rsp)
leaq 0x110(%rsi), %rax
movq %rax, 0x38(%rsp)
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r14, %rax
jbe 0x117c8
leaq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x892c
movl %eax, %ebp
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x11754
movq %rax, 0x18(%rsp)
movl %ebp, %r13d
negl %r13d
cmpl %ebp, %r13d
jg 0x117a6
testl %r13d, %r13d
je 0x117a1
movl %r14d, %eax
addl %r13d, %eax
js 0x117a1
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x117a1
movq 0x10(%r15), %rdi
movl (%rcx,%rax,4), %esi
callq 0x5e42
movq 0x18(%rsp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r12, %rdi
callq 0x15ce4
incl %r13d
jmp 0x1175a
movq (%rbx), %rax
movl (%rax,%r14,4), %edx
movq 0x30(%rsp), %rdi
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
callq 0xe22a
incq %r14
jmp 0x1171e
leaq 0x10(%rsp), %rdi
callq 0x8c0e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x117e5
jmp 0x117e5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::predict(std::istream&, int, std::vector<std::pair<float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&) const
void FastText::predict(std::istream& in, int32_t k,
                       std::vector<std::pair<real,std::string>>& predictions) const {
  std::vector<int32_t> words, labels;
  dict_->getLine(in, words, labels, model_->rng);
  if (words.empty()) return;
  Vector hidden(args_->dim);
  Vector output(dict_->nlabels());
  std::vector<std::pair<real,int32_t>> modelPredictions;
  model_->predict(words, k, modelPredictions, hidden, output);
  predictions.clear();
  for (auto it = modelPredictions.cbegin(); it != modelPredictions.cend(); it++) {
    predictions.push_back(std::make_pair(it->first, dict_->getLabel(it->second)));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq 0x10(%rdi), %rdi
movl $0x110, %r8d            # imm = 0x110
addq 0x60(%r14), %r8
callq 0x7650
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x11f92
movq (%r14), %rax
movslq 0x94(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0xd03c
movq 0x10(%r14), %rdi
callq 0x5e38
movslq %eax, %rsi
leaq 0x20(%rsp), %rdi
callq 0xd03c
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq 0x60(%r14), %rdi
movq %rsp, %rsi
leaq 0x30(%rsp), %r8
leaq 0x20(%rsp), %r9
movl %ebp, %edx
callq 0xde5a
movq %rbx, %rdi
callq 0x15d04
movq 0x40(%rsp), %r12
leaq 0xa8(%rsp), %r15
leaq 0x80(%rsp), %r13
leaq 0xa0(%rsp), %rbp
cmpq 0x48(%rsp), %r12
je 0x11f74
movq 0x10(%r14), %rsi
movl 0x4(%r12), %edx
movq %r13, %rdi
callq 0x7694
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x15e6a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x170e8
movq %r15, %rdi
callq 0x46c8
movq %r13, %rdi
callq 0x46c8
addq $0x8, %r12
jmp 0x11f2d
leaq 0x40(%rsp), %rdi
callq 0x16fec
leaq 0x20(%rsp), %rdi
callq 0xd066
leaq 0x30(%rsp), %rdi
callq 0xd066
leaq 0x60(%rsp), %rdi
callq 0x8c0e
movq %rsp, %rdi
callq 0x8c0e
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11fc4
jmp 0x11fba
movq %rax, %rbx
jmp 0x11fff
movq %rax, %rbx
jmp 0x11ff5
movq %rax, %rbx
jmp 0x11fe1
movq %rax, %rbx
movq %r15, %rdi
callq 0x46c8
leaq 0x80(%rsp), %rdi
callq 0x46c8
leaq 0x40(%rsp), %rdi
callq 0x16fec
leaq 0x20(%rsp), %rdi
callq 0xd066
leaq 0x30(%rsp), %rdi
callq 0xd066
leaq 0x60(%rsp), %rdi
callq 0x8c0e
movq %rsp, %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq 0x15f73(%rip), %r13     # 0x27fc0
leaq 0x8b15(%rip), %r12      # 0x1ab69
movq %r14, %rdi
callq 0x4130
cmpl $-0x1, %eax
je 0x120e9
movq 0x30(%rsp), %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x11e60
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0x120dc
cmpq %rax, %r15
je 0x120dc
cmpq 0x10(%rsp), %r15
je 0x120a1
movq %r13, %rdi
movq %r12, %rsi
callq 0x4330
leaq 0x8(%r15), %rsi
movq %r13, %rdi
callq 0x42f0
testb %bl, %bl
je 0x120d1
movq %r13, %rdi
movq %r12, %rsi
callq 0x4330
movq %rax, %rbp
movss (%r15), %xmm0
callq 0x4560
movq %rbp, %rdi
callq 0x4270
addq $0x28, %r15
movq 0x18(%rsp), %rax
jmp 0x1208a
movq %r13, %rdi
callq 0x4190
jmp 0x12054
leaq 0x10(%rsp), %rdi
callq 0x15d0c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12104
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15d0c
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::sentenceVectors()
void FastText::sentenceVectors() {
  Vector vec(args_->dim);
  std::string sentence;
  Vector svec(args_->dim);
  std::string word;
  while (std::getline(std::cin, sentence)) {
    std::istringstream iss(sentence);
    svec.zero();
    int32_t count = 0;
    while(iss >> word) {
      getVector(vec, word);
      vec.mul(1.0 / vec.norm());
      svec.addVector(vec);
      count++;
    }
    svec.mul(1.0 / count);
    std::cout << sentence << " " << svec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd03c
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd03c
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %r15
leaq 0x68(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x18(%rsp), %r14
movq 0x15d52(%rip), %rdi     # 0x27fd8
movq %r15, %rsi
callq 0x4090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1236f
movq %r12, %rdi
movq %r15, %rsi
pushq $0x8
popq %rdx
callq 0x4570
movq %r13, %rdi
callq 0xd078
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4400
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1230f
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf988
movq %r14, %rdi
callq 0xd090
movss 0x8e80(%rip), %xmm1     # 0x1b170
divss %xmm0, %xmm1
movq %r14, %rdi
movaps %xmm1, %xmm0
callq 0xd0cc
movq %r13, %rdi
movq %r14, %rsi
callq 0xd0f6
incl %r15d
jmp 0x122b9
cvtsi2sd %r15d, %xmm0
movsd 0x85cc(%rip), %xmm1     # 0x1a8e8
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movq %r13, %rdi
callq 0xd0cc
leaq 0x28(%rsp), %r15
movq 0x15c88(%rip), %rdi     # 0x27fc0
movq %r15, %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x881f(%rip), %rsi      # 0x1ab69
callq 0x4330
movq %rax, %rdi
movq %r13, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
movq %r12, %rdi
callq 0x4180
jmp 0x1227f
leaq 0x48(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x28(%rsp), %rdi
callq 0x46c8
leaq 0x18(%rsp), %rdi
callq 0xd066
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x123da
jmp 0x123b9
jmp 0x123b2
movq %rax, %rbx
jmp 0x123c6
jmp 0x123b9
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4180
leaq 0x48(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x28(%rsp), %rdi
callq 0x46c8
leaq 0x18(%rsp), %rdi
callq 0xd066
movq %rbx, %rdi
callq 0x45d0