LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1070d
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x88(%rdi)
jle 0x1072c
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x10700
movss %xmm0, 0xc(%rsp)
leaq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfe50
movq 0x40(%r14), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x10650
cmpl $0x2, %eax
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
jne 0x10662
callq 0xfa32
jmp 0x10667
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xfb2c
jmp 0x10667
callq 0xfd4c
addss 0x8c(%r14), %xmm0
movss %xmm0, 0x8c(%r14)
incq 0x90(%r14)
movq 0x40(%r14), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x106d2
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xe26b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe273(%rip), %xmm0     # 0x1e920
leaq 0x70(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xe22b(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xf01c
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x10700
leaq 0x70(%r14), %r15
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0xea7f(%rip), %xmm0     # 0x1f170
callq 0xdf54
addq $0x4, %r12
cmpq 0x8(%rbx), %r12
jne 0x106df
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xee9f(%rip), %rdi      # 0x1f5b3
leaq 0xedab(%rip), %rsi      # 0x1f4c6
leaq 0xee9d(%rip), %rcx      # 0x1f5bf
movl $0xcc, %edx
callq 0x41d0
leaq 0xeed6(%rip), %rdi      # 0x1f609
leaq 0xed8c(%rip), %rsi      # 0x1f4c6
leaq 0xee7e(%rip), %rcx      # 0x1f5bf
movl $0xcd, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10849
movl %edx, %r12d
movq %rdi, %r15
cmpl %edx, 0x88(%rdi)
jle 0x10868
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x1083a
movl %r8d, %ebx
movl %ecx, %ebp
movss %xmm0, (%rsp)
leaq 0x50(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xfe50
movq 0x40(%r15), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x107c6
cmpl $0x2, %eax
movss (%rsp), %xmm0
movq %r15, %rdi
movl %r12d, %esi
jne 0x107d8
callq 0xfa32
jmp 0x107dd
movq %r15, %rdi
movl %r12d, %esi
movss (%rsp), %xmm0
callq 0xfb2c
jmp 0x107dd
callq 0xfd4c
addss 0x8c(%r15), %xmm0
movss %xmm0, 0x8c(%r15)
incq 0x90(%r15)
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x1083a
leaq 0x70(%r15), %r12
movslq (%r13), %rdx
cmpl %ebp, %edx
setle %al
cmpl %ebx, %edx
setge %cl
movq (%r15), %rdi
movq %r12, %rsi
orb %al, %cl
jne 0x10823
movss 0x4(%rsp), %xmm0
jmp 0x1082b
movss 0xe945(%rip), %xmm0     # 0x1f170
callq 0xdf54
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x10803
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed63(%rip), %rdi      # 0x1f5b3
leaq 0xec6f(%rip), %rsi      # 0x1f4c6
leaq 0xedb9(%rip), %rcx      # 0x1f617
movl $0xe2, %edx
callq 0x41d0
leaq 0xed9a(%rip), %rdi      # 0x1f609
leaq 0xec50(%rip), %rsi      # 0x1f4c6
leaq 0xed9a(%rip), %rcx      # 0x1f617
movl $0xe3, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rax, 0x8(%rsi)
je 0x10999
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movapd 0xeb43(%rip), %xmm3     # 0x1f480
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jb 0x10952
sqrtsd %xmm0, %xmm0
jmp 0x10963
callq 0x4250
movapd 0xeb21(%rip), %xmm3     # 0x1f480
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
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x1093d
jmp 0x109a2
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x10a8b
leaq 0xa8(%rbx), %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r13,8), %xmm0
ucomisd 0xdf11(%rip), %xmm0     # 0x1e8e0
jb 0x109d7
sqrtsd %xmm0, %xmm0
jmp 0x109dc
callq 0x4250
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
andps 0xeaa6(%rip), %xmm1     # 0x1f490
mulss 0xea7e(%rip), %xmm1     # 0x1f470
divss 0x8(%rsp), %xmm1
ucomiss 0xe311(%rip), %xmm1     # 0x1ed10
jbe 0x10a71
movl $0x1, %ebp
movaps %xmm1, 0x10(%rsp)
movl %r13d, 0xc(%rsp)
movq 0xb0(%rbx), %rsi
cmpq 0xb8(%rbx), %rsi
je 0x10a30
movl %r13d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%rbx)
jmp 0x10a40
movq %r15, %rdi
movq %r12, %rdx
callq 0xb088
movaps 0x10(%rsp), %xmm1
testq %rbp, %rbp
js 0x10a4f
xorps %xmm0, %xmm0
cvtsi2ss %rbp, %xmm0
jmp 0x10a69
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 0x10a0b
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x109be
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rsi
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdx
callq 0xd9fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x65ba
movq %rbx, %rdi
callq 0xefcc
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x11c71
movq 0x20(%r14), %rsi
movslq (%r15), %rdx
movq %rbx, %rdi
callq 0xf0e6
addq $0x4, %r15
jmp 0x11c52
subq 0x8(%rsp), %rax
je 0x11cb5
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xcc87(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcc8f(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xcc4b(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf01c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11ccc
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11cd8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11cf2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x127e5
movq %rsp, %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43b0
cmpl $0xb, (%r14)
sete %al
jmp 0x127e7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %rsi
movl $0x2f4f16ba, (%rsi)     # imm = 0x2F4F16BA
movq %rsp, %r14
movl $0xb, (%r14)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8dc
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x4630
leaq 0x90(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12900
movq (%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5f4a
movq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x87d0
leaq 0x20(%rsp), %rdi
callq 0x4440
movq 0x176f6(%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 0x128f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq 0x176e9(%rip), %rdi     # 0x29ff0
leaq 0xce44(%rip), %rsi      # 0x1f752
movl $0x27, %edx
callq 0x4350
movq 0x176d1(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
jmp 0x12940
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4480
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12956
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x129c1
leaq 0x8(%rsp), %rsi
callq 0x127a4
testb %al, %al
je 0x129e7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a2a
leaq 0x8(%rsp), %rdi
callq 0x4090
leaq 0x8(%rsp), %rdi
callq 0x40c0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq 0x17628(%rip), %rdi     # 0x29ff0
leaq 0xcdab(%rip), %rsi      # 0x1f77a
movl $0x28, %edx
callq 0x4350
movq 0x17610(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x12a0b
movq 0x17602(%rip), %rdi     # 0x29ff0
leaq 0xcdae(%rip), %rsi      # 0x1f7a3
movl $0x21, %edx
callq 0x4350
movq 0x175ea(%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_O1/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 0x1a272
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x8(%r14), %rdi
movups %xmm0, (%r14)
testq %rdi, %rdi
je 0x12a75
callq 0xa86c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12a84
callq 0xa86c
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x1a3e6
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%r14), %rdi
movups %xmm0, 0x10(%r14)
testq %rdi, %rdi
je 0x12ac4
callq 0xa86c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12ad3
callq 0xa86c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6062
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x89c4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8dc
leaq 0xcc97(%rip), %rax      # 0x1f7c5
leaq 0xcc95(%rip), %rsi      # 0x1f7ca
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 0x12ca6
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 0x5f4a
movq 0x10(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x87d0
leaq 0x80(%rbx), %r14
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x43f0
cmpb $0x1, (%r14)
jne 0x12bf1
movq 0x40(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xed42
jmp 0x12bff
movq 0x20(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe2ca
movl $0x12c, %esi            # imm = 0x12C
addq (%rbx), %rsi
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x43f0
cmpb $0x1, (%r14)
jne 0x12c38
movq (%rbx), %rax
cmpb $0x1, 0x12c(%rax)
jne 0x12c38
movq 0x50(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xed42
jmp 0x12c46
movq 0x30(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe2ca
leaq 0x30(%rsp), %rdi
callq 0x4440
movq 0x17351(%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 0x12c99
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq 0x17343(%rip), %rdi     # 0x29ff0
leaq 0xca9e(%rip), %rsi      # 0x1f752
movl $0x27, %edx
callq 0x4350
movq 0x1732b(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
jmp 0x12cd6
movq %rax, %rbx
jmp 0x12ce8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4480
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12cff
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x131dc
movq %rsp, %rsi
callq 0x127a4
testb %al, %al
je 0x13202
testb %bpl, %bpl
je 0x131b3
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x13244
jmp 0x131be
movq %rsp, %rsi
movq %r14, %rdi
callq 0x136b4
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 0x16e0d(%rip), %rdi     # 0x29ff0
leaq 0xc590(%rip), %rsi      # 0x1f77a
movl $0x28, %edx
callq 0x4350
movq 0x16df5(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x13226
movq 0x16de7(%rip), %rdi     # 0x29ff0
leaq 0xc593(%rip), %rsi      # 0x1f7a3
movl $0x21, %edx
callq 0x4350
movq 0x16dcf(%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_O1/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 0xef90
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xe1fe
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
leaq 0x24(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0xd97e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x13d84
xorl %edx, %edx
movl %edx, (%rax)
incl %edx
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x13d77
movq 0x10(%r14), %rdi
leaq 0x165e1(%rip), %rsi     # 0x2a370
callq 0x6720
movq (%rbx), %r12
movq 0x8(%rbx), %r15
cmpq %r15, %r12
je 0x13e28
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 0x19976
cmpq $0x41, %r13
jl 0x13e15
leaq 0x40(%r12), %r13
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %ecx
callq 0x19dab
cmpq %r15, %r13
je 0x13e28
leaq 0x10(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x19e3d
addq $0x4, %r13
cmpq %r15, %r13
jne 0x13dfc
jmp 0x13e28
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x19dab
movslq %ebp, %rax
shlq $0x2, %rax
addq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x13e51
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x13e51
movq %rax, 0x8(%rbx)
leaq 0x10(%rsp), %rdi
callq 0xefba
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13e6f
movq %rax, %r14
jmp 0x13e8d
jmp 0x13e76
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13e8d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
leaq 0x10(%rsp), %rdi
callq 0xefba
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14383
movq %rdx, %rbx
movq 0x8(%rdx), %rcx
cmpq (%rdx), %rcx
je 0x14383
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 0xc0d8
cltq
movq (%r15), %rcx
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %rbx, %rsi
movss 0x4(%rsp), %xmm0
callq 0x105e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq (%rdi), %rax
movl 0x98(%rax), %eax
movl $0x1, 0x30(%rsp)
movl %eax, 0x34(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0x14976
movq %rdx, %rbx
movq 0x28(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x38(%rsp)
xorl %r12d, %r12d
leaq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rdi, %rdx
callq 0xc0d8
movl %eax, %r14d
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x148e1
movq %rax, 0x8(%rsp)
testl %r14d, %r14d
js 0x14945
leal 0x1(,%r14,2), %r13d
movl %r12d, %ebp
subl %r14d, %ebp
xorl %r15d, %r15d
cmpl %r15d, %r14d
je 0x1493d
movl %ebp, %eax
addl %r15d, %eax
js 0x1493d
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x1493d
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rdi
movl (%rcx,%rax,4), %esi
callq 0x655e
movq 0x8(%rsp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rsp, %rdi
callq 0x1ac8e
incl %r15d
cmpl %r15d, %r13d
jne 0x148f7
movq (%rbx), %rax
movl (%rax,%r12,4), %edx
movq 0x28(%rsp), %rdi
movq %rsp, %rsi
movss 0x24(%rsp), %xmm0
callq 0x105e0
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x148bc
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1498c
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 0x1499f
jmp 0x1499f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x149b8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14ac4(%rip), %r13     # 0x29fc0
leaq 0x965f(%rip), %r12      # 0x1eb62
movq %r14, %rdi
callq 0x4130
cmpl $-0x1, %eax
je 0x155b8
movq %r15, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x15212
movq 0x10(%rsp), %rbp
cmpq 0x18(%rsp), %rbp
je 0x1558b
cmpq 0x10(%rsp), %rbp
je 0x1554b
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 0x15585
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 0x1552d
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 0x15503
leaq 0x10(%rsp), %rdi
callq 0x1a09a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x155d3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a09a
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xef90
movq 0x149b0(%rip), %r14     # 0x29fd8
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x9529(%rip), %rbp      # 0x1eb62
movq %r14, %rdi
movq %r15, %rsi
callq 0x43d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x156c3
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11c28
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x1494f(%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 0xf3e9
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 0x15639
leaq 0x28(%rsp), %rdi
callq 0xefba
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x156e9
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 0x1570a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefba
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15726
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xef90
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rsi
callq 0x68e0
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x15afd
movl $0x8, %ebp
xorl %r15d, %r15d
leaq 0x38(%rsp), %r14
leaq 0x9105(%rip), %r12      # 0x1eb62
movq %r14, %rdi
callq 0xefcc
movq (%rsp), %rax
movslq (%rax,%r15,4), %rdx
testq %rdx, %rdx
js 0x15a7e
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xf0e6
movq 0x20(%rsp), %rax
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq 0x1452d(%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 0xf3e9
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 0x15a5d
leaq 0x38(%rsp), %rdi
callq 0xefba
leaq 0x20(%rsp), %rdi
callq 0xa654
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15b27
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 0x15b3d
movq %rax, %rbx
jmp 0x15b4a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xefba
leaq 0x20(%rsp), %rdi
callq 0xa654
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15b6a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVectors()
void FastText::textVectors() {
  std::vector<int32_t> line, labels;
  Vector vec(args_->dim);
  while (std::cin.peek() != EOF) {
    dict_->getLine(std::cin, line, labels, model_->rng);
    vec.zero();
    if (args_->model == model_name::bisent2vec){
      dict_->addNgrams(line, args_->wordNgrams);
    }
    for (auto it = line.cbegin(); it != line.cend(); ++it) {
      vec.addRow(*input_, *it);
    }
    if (!line.empty()) {
      vec.mul(1.0 / line.size());
    }
    std::cout << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
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 0xef90
movq 0x14422(%rip), %r14     # 0x29fd8
movq %rsp, %r15
leaq 0x38(%rsp), %r13
movq 0x143fb(%rip), %rbp     # 0x29fc0
movq %r14, %rdi
callq 0x4130
cmpl $-0x1, %eax
je 0x15cc3
movq 0x10(%rbx), %rdi
movq 0x60(%rbx), %r8
movl $0x110, %eax            # imm = 0x110
addq %rax, %r8
movq %r14, %rsi
movq %r15, %rdx
leaq 0x20(%rsp), %rcx
callq 0x86f4
movq %r13, %rdi
callq 0xefcc
movq (%rbx), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x15c1c
movq 0x10(%rbx), %rdi
movl 0xb4(%rax), %edx
movq %r15, %rsi
callq 0x82ba
movq (%rsp), %r12
movq 0x8(%rsp), %rax
cmpq %rax, %r12
je 0x15c40
movq 0x20(%rbx), %rsi
movslq (%r12), %rdx
movq %r13, %rdi
callq 0xf0e6
addq $0x4, %r12
jmp 0x15c20
movq (%rsp), %rcx
cmpq %rax, %rcx
je 0x15c89
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x8cb3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8cbb(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8c77(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r13, %rdi
callq 0xf01c
movq %rbp, %rdi
movq %r13, %rsi
callq 0xf3e9
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
jmp 0x15bc5
leaq 0x38(%rsp), %rdi
callq 0xefba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15ce4
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15cfa
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
movq %rax, %rbx
jmp 0x15d1d
jmp 0x15d10
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xefba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15d34
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15d4a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVectorThread(int, std::shared_ptr<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::shared_ptr<fasttext::Matrix>, int)
void FastText::textVectorThread(int thread_id, std::shared_ptr<std::vector<std::string>> sentences, std::shared_ptr<Matrix> emb, int num_threads) {
  std::vector<int32_t> line, labels;
  for (int sent_idx=thread_id; sent_idx < sentences->size(); sent_idx+=num_threads) {
    Vector vec(args_->dim);
    textVector(sentences->operator[](sent_idx), vec, line, labels);
    emb->addRow(vec, sent_idx, 1.);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movslq %esi, %rbx
movq (%rdx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %rbx, %rcx
jbe 0x15e64
movq %rdx, %r14
movq %rdi, %r15
movslq %r8d, %rbp
movq %rbx, %r12
shlq $0x5, %r12
orq $0x8, %r12
movq %rbp, 0x58(%rsp)
shlq $0x5, %rbp
leaq 0x68(%rsp), %r13
movq (%r15), %rax
movslq 0x94(%rax), %rsi
movq %r13, %rdi
callq 0xef90
movq (%r14), %rax
movq (%rax), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xa8dc
movq %r15, %rdi
movq %rsp, %rsi
movq %r13, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x15f0a
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x15e22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x60(%rsp), %rax
movq (%rax), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movss 0x9338(%rip), %xmm0     # 0x1f170
callq 0xdf54
movq %r13, %rdi
callq 0xefba
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
addq 0x58(%rsp), %rbx
sarq $0x5, %rcx
addq %rbp, %r12
cmpq %rbx, %rcx
ja 0x15dba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15e7b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x15e92
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x15ed3
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x15ec9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x15ec9
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xefba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15eea
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x15f01
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, fasttext::Vector&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void FastText::textVector(std::string text, Vector& vec, std::vector<int32_t>& line, std::vector<int32_t>& labels) {
  std::istringstream text_stream(text);
  dict_->getLine(text_stream, line, labels, model_->rng);
  vec.zero();
  if (args_->model == model_name::bisent2vec){
    dict_->addNgrams(line, args_->wordNgrams);
  }
  for (auto it = line.cbegin(); it != line.cend(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (!line.empty()) {
    vec.mul(1.0 / line.size());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rsp, %r13
movq %r13, %rdi
movl $0x8, %edx
callq 0x4540
movq 0x10(%r15), %rdi
movl $0x110, %r8d            # imm = 0x110
addq 0x60(%r15), %r8
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x86f4
movq %rbx, %rdi
callq 0xefcc
movq (%r15), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x15f78
movq 0x10(%r15), %rdi
movl 0xb4(%rax), %edx
movq %r14, %rsi
callq 0x82ba
movq (%r14), %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
je 0x15f9a
movq 0x20(%r15), %rsi
movslq (%r12), %rdx
movq %rbx, %rdi
callq 0xf0e6
addq $0x4, %r12
jmp 0x15f7b
movq (%r14), %rcx
cmpq %rax, %rcx
je 0x15fe2
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x895a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8962(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x891e(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf01c
movq 0x13fc7(%rip), %rsi     # 0x29fb0
movq %rsp, %rdi
callq 0x4450
leaq 0x78(%rsp), %rdi
callq 0x4110
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1600e
movq %rax, %rbx
movq 0x13f98(%rip), %rsi     # 0x29fb0
movq %rsp, %rdi
callq 0x4450
leaq 0x78(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::getVector(fasttext::Vector&, int) const
void FastText::getVector(Vector& vec, int32_t wordIdx) const {

  const std::vector<int32_t>& ngrams = dict_->getNgrams(wordIdx);
  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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x655e
movq %rax, %r15
movq %rbx, %rdi
callq 0xefcc
movq (%r15), %r12
movq 0x8(%r15), %rax
cmpq %rax, %r12
je 0x163bc
movq 0x20(%r14), %rsi
movslq (%r12), %rdx
movq %rbx, %rdi
callq 0xf0e6
addq $0x4, %r12
jmp 0x1639d
subq (%r15), %rax
je 0x16409
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x853e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8546(%rip), %xmm0     # 0x1e920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8502(%rip), %xmm0     # 0x1e8f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf01c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::precomputeWordVectors(fasttext::Matrix&)
void FastText::precomputeWordVectors(Matrix& wordVectors) {
  Vector vec(args_->dim);
  wordVectors.zero();
  std::cerr << "Pre-computing word vectors...";
  for (int32_t i = 0; i < dict_->nwords(); i++) {
    std::string word = dict_->getWord(i);
    getVector(vec, word);
    real norm = vec.norm();
    wordVectors.addRow(vec, i, 1.0 / norm);
  }
  std::cerr << " done." << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xef90
movq %rbx, %rdi
callq 0xddee
movq 0x138e1(%rip), %rdi     # 0x29ff0
leaq 0x914c(%rip), %rsi      # 0x1f862
movl $0x1d, %edx
callq 0x4350
leaq 0x28(%rsp), %rbp
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r13
movq 0x10(%r14), %rdi
callq 0x6550
cltq
cmpq %rax, %r15
jge 0x167a0
movq 0x10(%r14), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x6d2a
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x11c28
movq %r13, %rdi
callq 0xefe4
movss 0x8a01(%rip), %xmm1     # 0x1f170
divss %xmm0, %xmm1
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movaps %xmm1, %xmm0
callq 0xdf54
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1679b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x4300
incq %r15
jmp 0x16732
movq 0x13849(%rip), %rbx     # 0x29ff0
leaq 0x90d2(%rip), %rsi      # 0x1f880
movl $0x6, %edx
movq %rbx, %rdi
callq 0x4350
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq 0x13817(%rip), %rdi     # 0x29ff0
callq 0x4040
movq %rax, %rdi
callq 0x4200
leaq 0x8(%rsp), %rdi
callq 0xefba
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16805
jmp 0x16805
jmp 0x1680a
movq %rax, %rbx
jmp 0x16824
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x16824
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x8(%rsp), %rdi
callq 0xefba
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::nn(int)
void FastText::nn(int32_t k) {
  std::string queryWord;
  Vector queryVec(args_->dim);
  Matrix wordVectors(dict_->nwords(), args_->dim);
  precomputeWordVectors(wordVectors);
  std::set<std::string> banSet;
  std::cerr << "Query word? " << std::endl;
  while (std::cin >> queryWord) {
    banSet.clear();
    banSet.insert(queryWord);
    getVector(queryVec, queryWord);
    findNN(wordVectors, queryVec, k, banSet);
    std::cerr << "Query word? " << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
movq %rsp, %rdi
callq 0xef90
movq 0x10(%r14), %rdi
callq 0x6550
movslq %eax, %rsi
movq (%r14), %rax
movslq 0x94(%rax), %rdx
leaq 0x30(%rsp), %rdi
callq 0xdd04
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x166d8
leaq 0x50(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x12ddb(%rip), %r15     # 0x29ff0
leaq 0x868d(%rip), %rsi      # 0x1f8a9
movl $0xc, %edx
movq %r15, %rdi
callq 0x4350
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq 0x12da9(%rip), %r15     # 0x29ff0
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
leaq 0x10(%rsp), %r13
leaq 0x48(%rsp), %rbp
movq %rsp, %r12
movq 0x12d6d(%rip), %rdi     # 0x29fd8
movq %r13, %rsi
callq 0x43d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x172f7
movq %rbp, %rdi
callq 0x1b9e2
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1ba10
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x11c28
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
movl %ebx, %ecx
movq %rbp, %r8
callq 0x16a72
movl $0xc, %edx
movq %r15, %rdi
leaq 0x85e3(%rip), %rsi      # 0x1f8a9
callq 0x4350
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
jmp 0x17264
leaq 0x48(%rsp), %rdi
callq 0x1a1ba
leaq 0x30(%rsp), %rdi
callq 0xdde0
movq %rsp, %rdi
callq 0xefba
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1732f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x17361
movq %rax, %rbx
jmp 0x17373
movq %rax, %rbx
jmp 0x1736b
jmp 0x1734f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1a1ba
leaq 0x20(%rsp), %r15
leaq 0x30(%rsp), %rdi
callq 0xdde0
movq %rsp, %rdi
callq 0xefba
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1738a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::trainDict(std::shared_ptr<fasttext::Args>)
void FastText::trainDict(std::shared_ptr<Args> args) {
  args_ = args;
  dict_ = std::make_shared<Dictionary>(args_);
  if (args_->input == "-") {
    // manage expectations
    std::cerr << "Cannot use stdin for training!" << std::endl;
    exit(EXIT_FAILURE);
  }
  std::ifstream ifs(args_->input);
  if (!ifs.is_open()) {
    std::cerr << "Input file cannot be opened!" << std::endl;
    exit(EXIT_FAILURE);
  }
  dict_->readFromFile(ifs);
  saveDict();
  ifs.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x10fb4
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1a3e6
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0x1939d
callq 0xa86c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x193ac
callq 0xa86c
movq (%rbx), %rdi
leaq 0x6602(%rip), %rsi      # 0x1f9b8
callq 0x40e0
testl %eax, %eax
je 0x19417
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
movl $0x8, %edx
callq 0x44f0
leaq 0x88(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x1943c
movq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x712e
movq %rbx, %rdi
callq 0x12832
leaq 0x10(%rsp), %rdi
callq 0x4090
leaq 0x10(%rsp), %rdi
callq 0x40c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
movq 0x10bd2(%rip), %rdi     # 0x29ff0
leaq 0x6595(%rip), %rsi      # 0x1f9ba
callq 0x42e0
movq %rax, %rdi
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq 0x10bad(%rip), %rdi     # 0x29ff0
leaq 0x658f(%rip), %rsi      # 0x1f9d9
movl $0x1c, %edx
callq 0x4350
movq 0x10b95(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x19432
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45b0
nop