LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  boostNgrams = 1.0;
  dim = 100;
  ws = 5;
  dropoutK = 0;
  epoch = 5;
  minCount = 5;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::transgram;
  bucket = 2000000;
  bucketChar = 1;
  minn = 0;
  maxn = 0;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
  saveOutput = 0;
  maxVocabSize = -1;
  numCheckPoints = 1;
  qout = false;
  retrain = false;
  qnorm = false;
  cutoff = 0;
  dsub = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x60(%rdi), %r12
movb %al, 0x70(%rdi)
leaq 0xf0(%rdi), %rcx
movq %rcx, 0xe0(%rdi)
andq $0x0, 0xe8(%rdi)
leaq 0xe0(%rdi), %r13
movb %al, 0xf0(%rdi)
leaq 0x108(%rdi), %rbp
leaq 0x118(%rdi), %rcx
movq %rcx, 0x108(%rdi)
andq $0x0, 0x110(%rdi)
movb %al, 0x118(%rdi)
movaps 0x155fc(%rip), %xmm0    # 0x1a010
movups %xmm0, 0x80(%rdi)
movl $0x5, 0xa0(%rdi)
movaps 0x155f4(%rip), %xmm0    # 0x1a020
movups %xmm0, 0xa8(%rdi)
movaps 0x155f6(%rip), %xmm0    # 0x1a030
movups %xmm0, 0xbc(%rdi)
andq $0x0, 0xcc(%rdi)
movl $0xc, 0xd4(%rdi)
movaps 0x155e6(%rip), %xmm0    # 0x1a040
movups %xmm0, 0x90(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xd8(%rdi)
leaq 0x155d7(%rip), %rsi     # 0x1a050
movq %r13, %rdi
callq 0x4640
movl $0x2, 0x100(%rbx)
leaq 0x16dbc(%rip), %rsi     # 0x1b84e
movq %rbp, %rdi
callq 0x4640
andl $0x0, 0x128(%rbx)
orl $-0x1, 0xa4(%rbx)
movl $0x1, 0xb8(%rbx)
andw $0x0, 0x12c(%rbx)
movb $0x0, 0x12e(%rbx)
andq $0x0, 0x130(%rbx)
movq $0x2, 0x138(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
movq %rbp, %rdi
callq 0x46c8
movq %r13, %rdi
callq 0x46c8
movq %r12, %rdi
callq 0x46c8
movq %r15, %rdi
callq 0x46c8
movq %r14, %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x46c8
movq (%rsp), %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/args.cc
// Function: fasttext::Args::save(std::ostream&)
void Args::save(std::ostream& out) {
  out.write((char*) &(dim), sizeof(int));
  out.write((char*) &(ws), sizeof(int));
  out.write((char*) &(epoch), sizeof(int));
  out.write((char*) &(minCount), sizeof(int));
  out.write((char*) &(neg), sizeof(int));
  out.write((char*) &(wordNgrams), sizeof(int));
  out.write((char*) &(loss), sizeof(loss_name));
  out.write((char*) &(model), sizeof(model_name));
  out.write((char*) &(bucket), sizeof(int));
  out.write((char*) &(minn), sizeof(int));
  out.write((char*) &(maxn), sizeof(int));
  out.write((char*) &(lrUpdateRate), sizeof(int));
  out.write((char*) &(t), sizeof(double));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xa0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xa8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xb0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xb4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xbc(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xc0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xc4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xcc(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0xd0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x90(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
addq $0xd8, %r14
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/args.cc
// Function: fasttext::Args::load(std::istream&)
void Args::load(std::istream& in) {
  in.read((char*) &(dim), sizeof(int));
  in.read((char*) &(ws), sizeof(int));
  in.read((char*) &(epoch), sizeof(int));
  in.read((char*) &(minCount), sizeof(int));
  in.read((char*) &(neg), sizeof(int));
  in.read((char*) &(wordNgrams), sizeof(int));
  in.read((char*) &(loss), sizeof(loss_name));
  in.read((char*) &(model), sizeof(model_name));
  in.read((char*) &(bucket), sizeof(int));
  in.read((char*) &(minn), sizeof(int));
  in.read((char*) &(maxn), sizeof(int));
  in.read((char*) &(lrUpdateRate), sizeof(int));
  in.read((char*) &(t), sizeof(double));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xa0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xa8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xb0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xb4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xbc(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xc0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xc4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xcc(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0xd0(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x90(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
addq $0xd8, %r14
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int32_t Dictionary::find(const std::string& w) const {
  int32_t h = hash(w) % MAX_VOCAB_SIZE;
  while (word2int_[h] != -1 && words_[word2int_[h]].word != w) {
    h = (h + 1) % MAX_VOCAB_SIZE;
  }
  return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5d30
movl %eax, %r15d
movl $0x1c9c380, %ebp        # imm = 0x1C9C380
movl %r15d, %eax
xorl %edx, %edx
divl %ebp
movq 0x10(%r14), %rax
movl %edx, %r15d
movslq (%rax,%r15,4), %rax
cmpq $-0x1, %rax
je 0x5d21
imulq $0x48, %rax, %rdi
addq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x86cc
testb %al, %al
je 0x5d21
incl %r15d
jmp 0x5cf0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint32_t Dictionary::hash(const std::string& str) const {
  uint32_t h = 2166136261;
  for (size_t i = 0; i < str.size(); i++) {
    h = h ^ uint32_t(str[i]);
    h = h * 16777619;
  }
  return h;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x5d54
movsbl (%rcx,%rsi), %edi
xorl %edi, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rsi
jmp 0x5d3e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Dictionary::add(const std::string& w) {
  int32_t h = find(w);
  ntokens_++;
  if (word2int_[h] == -1) {
    entry e;
    e.word = w;
    e.count = 1;
    e.type = getType(w);
    words_.push_back(e);
    word2int_[h] = size_++;
  } else {
    words_[word2int_[h]].count++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5cd6
incq 0x68(%rbx)
movl %eax, %r12d
movq 0x10(%rbx), %rax
movslq (%rax,%r12,4), %rax
cmpq $-0x1, %rax
je 0x5d90
movq 0x28(%rbx), %rcx
imulq $0x48, %rax, %rax
incq 0x20(%rcx,%rax)
jmp 0x5df7
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x41d0
movq %rsp, %r15
movq $0x1, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e16
movb %al, 0x28(%r15)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x86d6
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
movq 0x10(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
movq %rsp, %rdi
callq 0x8702
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8702
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::vector<int32_t> Dictionary::getNgrams(const std::string& word) const {
  int32_t i = getId(word);
  if (i >= 0) {
    return getNgrams(i);
  }
  std::vector<int32_t> ngrams;
  computeNgrams(BOW + word + EOW, ngrams);
  return ngrams;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x5f5e
testl %eax, %eax
js 0x5ece
movq %r14, %rdi
movl %eax, %esi
callq 0x5e42
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8718
jmp 0x5f21
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x224c8(%rip), %rsi     # 0x283a8
movq %rsp, %rdi
movq %r15, %rdx
callq 0x8784
leaq 0x224d6(%rip), %rdx     # 0x283c8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x8765
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5f72
leaq 0x20(%rsp), %rdi
callq 0x46c8
movq %rsp, %rdi
callq 0x46c8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x46c8
jmp 0x5f40
movq %rax, %r14
movq %rsp, %rdi
callq 0x46c8
jmp 0x5f4d
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c0e
movq %r14, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::computeNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&) const
void Dictionary::computeNgrams(const std::string& word,
                               std::vector<int32_t>& ngrams) const {
  for (size_t i = 0; i < word.size(); i++) {
    std::string ngram;
    if ((word[i] & 0xC0) == 0x80) continue;
    for (size_t j = i, n = 1; j < word.size() && n <= args_->maxn; n++) {
      ngram.push_back(word[j++]);
      while (j < word.size() && (word[j] & 0xC0) == 0x80) {
        ngram.push_back(word[j++]);
      }
      if (n >= args_->minn && !(n == 1 && (i == 0 || j == word.size()))) {
        int32_t h = hash(ngram) % args_->bucket;
        ngrams.push_back(nwords_ + h);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %edx, %edx
leaq 0x18(%rsp), %r12
movq 0x8(%r14), %rax
cmpq %rax, %rdx
jae 0x6086
leaq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq (%r14), %rcx
movq %rdx, (%rsp)
movb (%rcx,%rdx), %cl
andb $-0x40, %cl
negb %cl
jno 0x5fd6
movq %r12, %rdi
callq 0x46c8
movq (%rsp), %rdx
incq %rdx
jmp 0x5f92
movq (%rsp), %rbp
pushq $0x1
popq %rbx
cmpq %rax, %rbp
jae 0x5fc5
movq (%r15), %rax
movslq 0xd0(%rax), %rax
cmpq %rax, %rbx
ja 0x5fc5
movq (%r14), %rax
movsbl (%rax,%rbp), %esi
movq %r12, %rdi
callq 0x42d0
incq %rbp
movq 0x8(%r14), %rax
cmpq %rax, %rbp
jae 0x602b
movq (%r14), %rcx
movb (%rcx,%rbp), %cl
movl %ecx, %edx
andb $-0x40, %dl
negb %dl
jno 0x602b
incq %rbp
movsbl %cl, %esi
movq %r12, %rdi
callq 0x42d0
jmp 0x6003
movq (%r15), %r13
movslq 0xcc(%r13), %rcx
cmpq %rcx, %rbx
jb 0x607e
cmpq $0x0, (%rsp)
sete %cl
cmpq %rax, %rbp
sete %dl
cmpq $0x1, %rbx
jne 0x6052
orb %dl, %cl
jne 0x607e
movq %r12, %rsi
callq 0x5d30
xorl %edx, %edx
divl 0xc4(%r13)
addl 0x5c(%r15), %edx
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x9292
movq 0x8(%r14), %rax
incq %rbx
jmp 0x5fdd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6099
jmp 0x6099
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, 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>>>>&) const
void Dictionary::getNgrams(const std::string& word,
                           std::vector<int32_t>& ngrams,
                           std::vector<std::string>& substrings) const {
  int32_t i = getId(word);
  ngrams.clear();
  substrings.clear();
  if (i >= 0) {
    ngrams.push_back(i);
    substrings.push_back(words_[i].word);
  } else {
    ngrams.push_back(-1);
    substrings.push_back(word);
  }
  computeNgrams(BOW + word + EOW, ngrams, substrings);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x5f5e
movl %eax, %ebp
movl %eax, 0x4(%rsp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x60e0
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x87bc
testl %ebp, %ebp
js 0x610a
leaq 0x4(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x87c4
movslq (%r13), %rax
imulq $0x48, %rax, %rsi
addq 0x28(%r15), %rsi
jmp 0x611d
leaq 0x8(%rsp), %rsi
orl $-0x1, (%rsi)
movq %r14, %rdi
callq 0x9292
movq %r12, %rsi
movq %rbx, %rdi
callq 0x87e2
leaq 0x2227c(%rip), %rsi     # 0x283a8
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x8784
leaq 0x22285(%rip), %rdx     # 0x283c8
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x8765
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x61aa
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x28(%rsp), %rdi
callq 0x46c8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x6198
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::bisent2vec) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x632b
cmpl %esi, 0x5c(%rdi)
jle 0x6344
movq (%rdi), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x631c
xorl %eax, %eax
jmp 0x6329
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0x1487e(%rip), %rdi     # 0x1abb0
leaq 0x1460d(%rip), %rsi     # 0x1a946
leaq 0x1466f(%rip), %rcx     # 0x1a9af
pushq $0x62
jmp 0x635b
leaq 0x1469c(%rip), %rdi     # 0x1a9e7
leaq 0x145f4(%rip), %rsi     # 0x1a946
leaq 0x14656(%rip), %rcx     # 0x1a9af
pushq $0x63
popq %rdx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getVocab[abi:cxx11]() const
std::vector<std::string> Dictionary::getVocab() const {
  std::vector<std::string> vocab;
  for (auto& w : words_) {
    if (w.type == entry_type::word) vocab.push_back(w.word);
  }
  return vocab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
cmpq %r15, %r14
je 0x6444
cmpb $0x0, 0x28(%r14)
jne 0x643e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x87e2
addq $0x48, %r14
jmp 0x6427
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x880e
movq %r14, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::initNgrams()
void Dictionary::initNgrams() {
  for (size_t i = 0; i < size_; i++) {
    std::string word = BOW + words_[i].word + EOW;
    words_[i].subwords.push_back(i);
    computeNgrams(word, words_[i].subwords);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $0x30
popq %rbp
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
leaq 0x21e95(%rip), %r12     # 0x283c8
leaq 0x28(%rsp), %r13
movslq 0x58(%rbx), %rax
cmpq %rax, %r14
jae 0x65a9
movq 0x28(%rbx), %rax
leaq (%rax,%rbp), %rdx
addq $-0x30, %rdx
movq %r15, %rdi
leaq 0x21e51(%rip), %rsi     # 0x283a8
callq 0x8784
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8765
movq %r15, %rdi
callq 0x46c8
movq 0x28(%rbx), %rdi
addq %rbp, %rdi
movl %r14d, 0x8(%rsp)
movq %r15, %rsi
callq 0x9292
movq 0x28(%rbx), %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5f72
movq %r13, %rdi
callq 0x46c8
incq %r14
addq $0x48, %rbp
jmp 0x6538
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65ba
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x65cc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::readWord(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
bool Dictionary::readWord(std::istream& in, std::string& word) const
{
  char c;
  std::streambuf& sb = *in.rdbuf();
  word.clear();
  while ((c = sb.sbumpc()) != EOF) {
    if (c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\v' ||
        c == '\f' || c == '\0') {
      if (word.empty()) {
        if (c == '\n') {
          word += EOS;
          return true;
        }
        continue;
      } else {
        if (c == '\n')
          sb.sungetc();
        return true;
      }
    }
    word.push_back(c);
  }
  // trigger eofbit
  in.get();
  return !word.empty();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %r14
andq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x41c0
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x6663
movl %eax, %edx
andl $0xfb, %edx
cmpl $0x9, %edx
jne 0x6632
cmpq $0x0, 0x8(%rbx)
jne 0x6675
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x65ff
jmp 0x6689
testl %ecx, %ecx
je 0x6621
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x6621
cmpl $0xb000000, %ecx        # imm = 0xB000000
je 0x6621
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x6621
cmpl $0xc000000, %ecx        # imm = 0xC000000
je 0x6621
movsbl %al, %esi
movq %rbx, %rdi
callq 0x42d0
jmp 0x65ff
movq %r15, %rdi
callq 0x43a0
cmpq $0x0, 0x8(%rbx)
setne %bl
jmp 0x669a
movb $0x1, %bl
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x669a
movq %r14, %rdi
callq 0x4200
jmp 0x669a
leaq 0x21cf8(%rip), %rsi     # 0x28388
movq %rbx, %rdi
callq 0x4670
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::initTableDiscard()
void Dictionary::initTableDiscard() {
  pdiscard_.resize(size_);
  for (size_t i = 0; i < size_; i++) {
    real f = real(words_[i].count) / real(ntokens_);
    pdiscard_[i] = std::sqrt(args_->t / f) + args_->t / f;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x40, %rdi
movslq 0x58(%rbx), %rsi
callq 0x886c
pushq $0x8
popq %r14
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movslq 0x58(%rbx), %rax
cmpq %rax, %r15
jae 0x6df3
movq 0x28(%rbx), %rax
cvtsi2ssq (%rax,%r14,4), %xmm1
cvtsi2ssq 0x68(%rbx), %xmm0
movq (%rbx), %rax
divss %xmm0, %xmm1
movsd 0xd8(%rax), %xmm0
cvtss2sd %xmm1, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jb 0x6db4
sqrtsd %xmm0, %xmm0
jmp 0x6dc9
movsd %xmm3, 0x8(%rsp)
callq 0x42a0
movsd 0x8(%rsp), %xmm3
xorpd %xmm2, %xmm2
movq (%rbx), %rax
movsd 0xd8(%rax), %xmm1
divsd %xmm3, %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movq 0x40(%rbx), %rax
movss %xmm0, (%rax,%r15,4)
incq %r15
addq $0x12, %r14
jmp 0x6d78
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getCounts(fasttext::entry_type) const
std::vector<int64_t> Dictionary::getCounts(entry_type type) const {
  std::vector<int64_t> counts;
  for (auto& w : words_) {
    if (w.type == type) counts.push_back(w.count);
  }
  return counts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
cmpq %r15, %r14
je 0x6e3a
cmpb %bpl, 0x28(%r14)
jne 0x6e34
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x889e
addq $0x48, %r14
jmp 0x6e1d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9a28
movq %r14, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::addNgrams(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>> const&, int) const
void Dictionary::addNgrams(std::vector<int32_t>& line,
                           const std::vector<int32_t>& hashes,
                           int32_t n) const {
  if (pruneidx_size_ == 0) return;
  for (int32_t i = 0; i < hashes.size(); i++) {
    uint64_t h = hashes[i];
    for (int32_t j = i + 1; j < hashes.size() && j < i + n; j++) {
      h = h * 116049371 + hashes[j];
      int64_t id = h % args_->bucket;
      if (pruneidx_size_ > 0) {
        if (pruneidx_.count(id)) {
          id = pruneidx_.at(id);
        } else {continue;}
      }
      line.push_back(nwords_ + id);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x70(%rdi)
je 0x6fb1
movq %rdx, %rbx
movq %rdi, %r15
movabsq $0x100000000, %r12      # imm = 0x100000000
leaq 0x78(%rdi), %rax
movq %rax, 0x10(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x1
popq %r14
xorl %esi, %esi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x6fb1
movslq (%rax,%rsi,4), %r13
movq 0x18(%rsp), %rdx
movq %rsi, 0x28(%rsp)
addq %rsi, %rdx
movq %rdx, 0x40(%rsp)
movq %r12, 0x20(%rsp)
movq %r14, 0x30(%rsp)
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0x6f8a
movq %r12, %rdx
sarq $0x20, %rdx
cmpq 0x40(%rsp), %rdx
jge 0x6f8a
imulq $0x6eac5db, %r13, %rcx  # imm = 0x6EAC5DB
movslq (%rax,%r14,4), %r13
addq %rcx, %r13
movq (%r15), %rax
movslq 0xc4(%rax), %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rbp
cmpq $0x0, 0x70(%r15)
jle 0x6f57
movl %ebp, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x9ba0
testq %rax, %rax
je 0x6f6e
movl %ebp, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9c30
movl (%rax), %ebp
addl 0x5c(%r15), %ebp
movl %ebp, 0x4(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x9292
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rdx, %r12
jmp 0x6edb
movq 0x28(%rsp), %rsi
incq %rsi
movq 0x30(%rsp), %r14
incq %r14
movabsq $0x100000000, %rdx      # imm = 0x100000000
movq 0x20(%rsp), %r12
addq %rdx, %r12
jmp 0x6ea8
addq $0x48, %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/dictionary.cc
// Function: fasttext::Dictionary::addNgrams(std::vector<int, std::allocator<int>>&, int) const
void Dictionary::addNgrams(std::vector<int32_t>& line, int32_t n) const {
  int32_t line_size = line.size();
  for (int32_t i = 0; i < line_size; i++) {
    uint64_t h = line[i];
    for (int32_t j = i + 1; j < line_size && j < i + n; j++) {
      h = h * 116049371 + line[j];
      line.push_back(nwords_ + (h % args_->bucket));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x2, %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
movq %rax, 0x10(%rsp)
cmovgl %eax, %edx
movq %rdx, 0x20(%rsp)
pushq $0x1
popq %rbx
leaq 0xc(%rsp), %r12
cmpq 0x20(%rsp), %rcx
je 0x7421
movq (%r14), %rax
movslq (%rax,%rcx,4), %r13
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
leal (%rcx,%rax), %ebp
movq 0x10(%rsp), %rax
cmpl %ebp, %eax
cmovll %eax, %ebp
movq %rbx, 0x28(%rsp)
cmpl %ebx, %ebp
jle 0x740f
imulq $0x6eac5db, %r13, %rax  # imm = 0x6EAC5DB
movq (%r14), %rcx
movslq (%rcx,%rbx,4), %r13
addq %rax, %r13
movq (%r15), %rax
movslq 0xc4(%rax), %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
addl 0x5c(%r15), %edx
movl %edx, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x9292
incq %rbx
jmp 0x73d0
movq 0x30(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %rbx
incq %rbx
jmp 0x73a6
addq $0x38, %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/dictionary.cc
// Function: fasttext::Dictionary::save(std::ostream&) const
void Dictionary::save(std::ostream& out) const {
  out.write((char*) &size_, sizeof(int32_t));
  out.write((char*) &nwords_, sizeof(int32_t));
  out.write((char*) &nlabels_, sizeof(int32_t));
  out.write((char*) &ntokens_, sizeof(int64_t));
  out.write((char*) &pruneidx_size_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    entry e = words_[i];
    out.write(e.word.data(), e.word.size() * sizeof(char));
    out.put(0);
    out.write((char*) &(e.count), sizeof(int64_t));
    out.write((char*) &(e.type), sizeof(entry_type));
  }
  for (const auto pair : pruneidx_) {
    out.write((char*) &(pair.first), sizeof(int32_t));
    out.write((char*) &(pair.second), sizeof(int32_t));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %r15
pushq $0x4
popq %r12
movq %rsi, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4430
leaq 0x5c(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4430
leaq 0x60(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4430
leaq 0x68(%r14), %rsi
pushq $0x8
popq %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4430
leaq 0x70(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4430
xorl %ebp, %ebp
movq %rsp, %r12
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x77d3
movq 0x28(%r14), %rsi
addq %rbp, %rsi
movq %r12, %rdi
callq 0x89b0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4430
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4040
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4430
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq %r12, %rdi
callq 0x8702
incq %r13
addq $0x48, %rbp
jmp 0x7770
addq $0x88, %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
pushq $0x4
popq %r13
movq (%r14), %r14
testq %r14, %r14
je 0x7814
movq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4430
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4430
jmp 0x77e6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8702
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::load(std::istream&)
void Dictionary::load(std::istream& in) {
  words_.clear();
  std::fill(word2int_.begin(), word2int_.end(), -1);
  in.read((char*) &size_, sizeof(int32_t));
  in.read((char*) &nwords_, sizeof(int32_t));
  in.read((char*) &nlabels_, sizeof(int32_t));
  in.read((char*) &ntokens_, sizeof(int64_t));
  in.read((char*) &pruneidx_size_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    char c;
    entry e;
    while ((c = in.get()) != 0) {
      e.word.push_back(c);
    }
    in.read((char*) &e.count, sizeof(int64_t));
    in.read((char*) &e.type, sizeof(entry_type));
    words_.push_back(e);
    word2int_[find(e.word)] = i;
  }
  pruneidx_.clear();
  for (int32_t i = 0; i < pruneidx_size_; i++) {
    int32_t first;
    int32_t second;
    in.read((char*) &first, sizeof(int32_t));
    in.read((char*) &second, sizeof(int32_t));
    pruneidx_[first] = second;
  }
  initTableDiscard();
  initNgrams();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movq %rdi, 0x10(%rsp)
callq 0x89fa
movq 0x10(%rbx), %rax
movq %rbx, (%rsp)
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x7872
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x7864
movq (%rsp), %rbx
leaq 0x58(%rbx), %r13
pushq $0x4
popq %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43e0
leaq 0x5c(%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x43e0
leaq 0x60(%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x43e0
leaq 0x68(%rbx), %rsi
pushq $0x8
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x70(%rbx), %rsi
movq %r14, %rdi
movq %rsi, 0x18(%rsp)
movq %r15, %rdx
callq 0x43e0
leaq 0x30(%rsp), %r12
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbp
movq (%rsp), %rbx
cmpl (%r13), %r15d
jge 0x7976
movq %r12, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
andq $0x0, 0x30(%r12)
movq %r14, %rdi
callq 0x43a0
testb %al, %al
je 0x7924
movsbl %al, %esi
movq %rbp, %rdi
callq 0x42d0
jmp 0x790b
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x43e0
movq %r14, %rdi
leaq 0x48(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x43e0
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x86d6
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5cd6
movq 0x10(%rbx), %rcx
movl %eax, %eax
movl %r15d, (%rcx,%rax,4)
movq %rbp, %rdi
callq 0x8702
incl %r15d
jmp 0x78e2
movq (%rsp), %rax
leaq 0x78(%rax), %r15
movq %r15, %rdi
callq 0xa4f8
xorl %r12d, %r12d
leaq 0x20(%rsp), %r13
pushq $0x4
popq %rbp
movq 0x18(%rsp), %rax
cmpq %r12, (%rax)
jle 0x79cf
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x43e0
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
movq %rbp, %rdx
callq 0x43e0
movl 0xc(%rsp), %ebx
movq %r15, %rdi
movq %r13, %rsi
callq 0xa55e
movl %ebx, (%rax)
incq %r12
jmp 0x7991
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x6d54
movq %rbx, %rdi
callq 0x6510
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x79f4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8702
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/productquantizer.cc
// Function: fasttext::distL2(float const*, float const*, int)
real distL2(const real* x, const real* y, int32_t d) {
  real dist = 0;
  for (auto i = 0; i < d; i++) {
    auto tmp = x[i] - y[i];
    dist += tmp * tmp;
  }
  return dist;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorps %xmm0, %xmm0
cmpq %rax, %rdx
je 0xaf66
movss (%rdi,%rax,4), %xmm1
subss (%rsi,%rax,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rax
jmp 0xaf4a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/productquantizer.cc
// Function: fasttext::ProductQuantizer::assign_centroid(float const*, float const*, unsigned char*, int) const
real ProductQuantizer::assign_centroid(const real * x, const real* c0,
                                       uint8_t* code, int32_t d) const {
  const real* c = c0;
  real dis = distL2(x, c, d);
  code[0] = 0;
  for (auto j = 1; j < ksub_; j++) {
    c += d;
    real disij = distL2(x, c, d);
    if (disij < dis) {
      code[0] = (uint8_t) j;
      dis = disij;
    }
  }
  return dis;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movl %r8d, %edx
callq 0xaf40
movss %xmm0, 0xc(%rsp)
movq %r14, 0x10(%rsp)
movb $0x0, (%r14)
movslq %ebx, %rbp
leaq (%r13,%rbp,4), %r13
shlq $0x2, %rbp
pushq $0x1
popq %r14
cmpl 0x4(%r12), %r14d
jge 0xb0d5
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0xaf40
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0xb0cd
movq 0x10(%rsp), %rax
movb %r14b, (%rax)
movss %xmm0, 0xc(%rsp)
incl %r14d
addq %rbp, %r13
jmp 0xb0a0
movss 0xc(%rsp), %xmm0
addq $0x18, %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/productquantizer.cc
// Function: fasttext::ProductQuantizer::kmeans(float const*, float*, int, int)
void ProductQuantizer::kmeans(const real *x, real* c, int32_t n, int32_t d) {
  std::vector<int32_t> perm(n,0);
  std::iota(perm.begin(), perm.end(), 0);
  std::shuffle(perm.begin(), perm.end(), rng);
  for (auto i = 0; i < ksub_; i++) {
    memcpy (&c[i * d], x + perm[i] * d, d * sizeof(real));
  }
  uint8_t* codes = new uint8_t[n];
  for (auto i = 0; i < niter_; i++) {
    Estep(x, c, codes, d, n);
    MStep(x, c, codes, d, n);
  }
  delete [] codes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, %r15
movslq %ecx, %r12
leaq 0x3c(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x40(%rsp), %r14
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x8676
movq (%r14), %rdi
movq 0x8(%r14), %rsi
xorl %eax, %eax
movq %rdi, %rcx
cmpq %rsi, %rcx
je 0xb42d
movl %eax, (%rcx)
incl %eax
addq $0x4, %rcx
jmp 0xb41e
movl %ebp, 0xc(%rsp)
leaq 0x48(%r15), %rdx
callq 0xbafd
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl %ebx, 0x1c(%rsp)
movslq %ebx, %rbx
leaq (,%rbx,4), %r13
xorl %ebp, %ebp
movq 0x28(%rsp), %r14
movslq 0x4(%r15), %rax
cmpq %rax, %rbp
jge 0xb48c
movq 0x10(%rsp), %rax
movslq (%rax,%rbp,4), %rax
imulq %rbx, %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rax,4), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x42b0
incq %rbp
addq %r13, %r14
jmp 0xb45a
movq %r12, %rdi
callq 0x4030
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movq 0x30(%rsp), %r12
movq 0x28(%rsp), %r13
movq 0x20(%rsp), %rbp
movl 0x1c(%rsp), %r14d
cmpl 0x14(%r15), %eax
jge 0xb4f3
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %r14d, %r8d
movl 0xc(%rsp), %r9d
callq 0xb0ea
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %r14d, %r8d
movl 0xc(%rsp), %r9d
callq 0xb148
movl 0x10(%rsp), %eax
incl %eax
jmp 0xb4af
movq 0x20(%rsp), %rdi
callq 0x4410
leaq 0x40(%rsp), %rdi
callq 0x8c0e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb51a
jmp 0xb51a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/productquantizer.cc
// Function: fasttext::ProductQuantizer::train(int, float const*)
void ProductQuantizer::train(int32_t n, const real * x) {
  if (n < ksub_) {
    std::cerr<<"Matrix too small for quantization, must have > 256 rows"<<std::endl;
    exit(1);
  }
  std::vector<int32_t> perm(n, 0);
  std::iota(perm.begin(), perm.end(), 0);
  auto d = dsub_;
  auto np = std::min(n, max_points_);
  real* xslice = new real[np * dsub_];
  for (auto m = 0; m < nsubq_; m++) {
    if (m == nsubq_-1) {d = lastdsub_;}
    if (np != n) {std::shuffle(perm.begin(), perm.end(), rng);}
    for (auto j = 0; j < np; j++) {
      memcpy (xslice + j * d, x + perm[j] * dim_ + m * dsub_, d * sizeof(real));
    }
    kmeans(xslice, get_centroids(m, 0), np, d);
  }
  delete [] xslice;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x30(%rsp)
cmpl %esi, 0x4(%rdi)
jg 0xb6d8
movl %esi, %r14d
movq %rdi, %r15
movslq %esi, %rsi
leaq 0x64(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x48(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x8676
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
je 0xb587
movl %edx, (%rax)
incl %edx
addq $0x4, %rax
jmp 0xb578
movl 0xc(%r15), %eax
movl 0x24(%r15), %r12d
cmpl %r14d, %eax
movl %r14d, %ebx
movl %eax, 0x10(%rsp)
cmovll %eax, %ebx
movl %ebx, %eax
imull %r12d, %eax
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x4030
movq %rax, %r13
leaq 0x48(%r15), %rax
movq %rax, 0x18(%rsp)
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
movq %rax, 0x40(%rsp)
movl %r14d, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
xorl %ebx, %ebx
movq %r15, 0x28(%rsp)
movq %r13, 0x20(%rsp)
movl 0x20(%r15), %eax
cmpl %eax, %ebx
jge 0xb6b7
decl %eax
cmpl %eax, %ebx
jne 0xb600
movl 0x28(%r15), %r12d
movq 0x48(%rsp), %rbp
cmpl %r14d, 0x10(%rsp)
jge 0xb623
movq 0x50(%rsp), %rsi
movq %rbp, %rdi
movq 0x18(%rsp), %rdx
callq 0xbafd
movq 0x48(%rsp), %rbp
movslq 0x1c(%r15), %r14
movslq 0x24(%r15), %rax
movq %rbx, 0x38(%rsp)
movslq %ebx, %rcx
imulq %rax, %rcx
movq 0x30(%rsp), %rax
leaq (%rax,%rcx,4), %rbx
movl %r12d, 0x14(%rsp)
movslq %r12d, %r12
shlq $0x2, %r12
xorl %r15d, %r15d
cmpq %r15, 0x40(%rsp)
je 0xb676
movslq (%rbp,%r15,4), %rax
imulq %r14, %rax
leaq (%rbx,%rax,4), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x42b0
incq %r15
addq %r12, %r13
jmp 0xb64f
movq 0x28(%rsp), %r15
movq %r15, %rdi
movq 0x38(%rsp), %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0xb020
movq %r15, %rdi
movq 0x20(%rsp), %r13
movq %r13, %rsi
movq %rax, %rdx
movl 0x8(%rsp), %ecx
movl 0x14(%rsp), %r12d
movl %r12d, %r8d
callq 0xb3d2
movl 0xc(%rsp), %r14d
incl %ebx
jmp 0xb5ea
movq %r13, %rdi
callq 0x4410
leaq 0x48(%rsp), %rdi
callq 0x8c0e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1c911(%rip), %rdi     # 0x27ff0
leaq 0xf5da(%rip), %rsi      # 0x1acc0
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0xb6fd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/productquantizer.cc
// Function: fasttext::ProductQuantizer::mulcode(fasttext::Vector const&, unsigned char const*, int, float) const
real ProductQuantizer::mulcode(const Vector& x, const uint8_t* codes,
                               int32_t t, real alpha) const {
  real res = 0.0;
  auto d = dsub_;
  const uint8_t* code = codes + nsubq_ * t;
  for (auto m = 0; m < nsubq_; m++) {
    const real* c = get_centroids(m, code[m]);
    if (m == nsubq_ - 1) {d = lastdsub_;}
    for(auto n = 0; n < d; n++) {
      res += x[m * dsub_ + n] * c[n];
    }
  }
  return res * alpha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0x14(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %r13d
movl 0x24(%rdi), %eax
movl %eax, 0x10(%rsp)
imull %r13d, %ecx
movslq %ecx, %rax
addq %rdx, %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r15d, %r15d
movslq %r13d, %rax
cmpq %rax, %r15
jge 0xb7e9
movq 0x18(%rsp), %rax
movzbl (%rax,%r15), %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0xafea
movq %rax, %r12
decl %r13d
cmpq %r13, %r15
jne 0xb786
movl 0x28(%r14), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
testl %eax, %eax
movl $0x0, %r13d
cmovgl %eax, %r13d
movq %r15, 0x20(%rsp)
movslq %r15d, %rbp
xorl %r15d, %r15d
cmpq %r15, %r13
je 0xb7d8
movslq 0x24(%r14), %rsi
imulq %rbp, %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0xd460
movss (%rax), %xmm0
mulss (%r12,%r15,4), %xmm0
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
incq %r15
jmp 0xb7a1
movq 0x20(%rsp), %r15
incq %r15
movl 0x20(%r14), %r13d
jmp 0xb752
movss 0xc(%rsp), %xmm0
mulss 0x14(%rsp), %xmm0
addq $0x28, %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/productquantizer.cc
// Function: fasttext::ProductQuantizer::addcode(fasttext::Vector&, unsigned char const*, int, float) const
void ProductQuantizer::addcode(Vector& x, const uint8_t* codes,
                               int32_t t, real alpha) const {
  auto d = dsub_;
  const uint8_t* code = codes + nsubq_ * t;
  for (auto m = 0; m < nsubq_; m++) {
    const real* c = get_centroids(m, code[m]);
    if (m == nsubq_ - 1) {d = lastdsub_;}
    for(auto n = 0; n < d; n++) {
      x[m * dsub_ + n] += alpha * c[n];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %r13d
movl 0x24(%rdi), %eax
movl %eax, 0xc(%rsp)
imull %r13d, %ecx
movslq %ecx, %rax
addq %rdx, %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
movslq %r13d, %rax
cmpq %rax, %r15
jge 0xb8d8
movq 0x18(%rsp), %rax
movzbl (%rax,%r15), %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0xafea
movq %rax, %r12
decl %r13d
cmpq %r13, %r15
jne 0xb86f
movl 0x28(%r14), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
testl %eax, %eax
movl $0x0, %r13d
cmovgl %eax, %r13d
movq %r15, 0x20(%rsp)
movslq %r15d, %rbp
xorl %r15d, %r15d
cmpq %r15, %r13
je 0xb8c7
movslq 0x24(%r14), %rsi
imulq %rbp, %rsi
addq %r15, %rsi
movss (%r12,%r15,4), %xmm0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movq %rbx, %rdi
callq 0xd452
movss 0x14(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incq %r15
jmp 0xb88a
movq 0x20(%rsp), %r15
incq %r15
movl 0x20(%r14), %r13d
jmp 0xb83b
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/productquantizer.cc
// Function: fasttext::ProductQuantizer::compute_code(float const*, unsigned char*) const
void ProductQuantizer::compute_code(const real* x, uint8_t* code) const {
  auto d = dsub_;
  for (auto m = 0; m < nsubq_; m++) {
    if (m == nsubq_ - 1) {d = lastdsub_;}
    assign_centroid(x + m * dsub_, get_centroids(m, 0), code + m, d);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x24(%rdi), %ebp
xorl %r13d, %r13d
movslq 0x20(%r15), %rax
cmpq %rax, %r13
jge 0xb949
decl %eax
cmpq %rax, %r13
jne 0xb916
movl 0x28(%r15), %ebp
movslq 0x24(%r15), %rax
movslq %r13d, %rsi
imulq %rsi, %rax
leaq (%r14,%rax,4), %r12
movq %r15, %rdi
xorl %edx, %edx
callq 0xafea
leaq (%rbx,%r13), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %ebp, %r8d
callq 0xb056
incq %r13
jmp 0xb902
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/productquantizer.cc
// Function: fasttext::ProductQuantizer::save(std::ostream&)
void ProductQuantizer::save(std::ostream& out) {
  out.write((char*) &dim_, sizeof(dim_));
  out.write((char*) &nsubq_, sizeof(nsubq_));
  out.write((char*) &dsub_, sizeof(dsub_));
  out.write((char*) &lastdsub_, sizeof(lastdsub_));
  out.write((char*) centroids_.data(), centroids_.size() * sizeof(real));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rdi), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x24(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4430
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/productquantizer.cc
// Function: fasttext::ProductQuantizer::load(std::istream&)
void ProductQuantizer::load(std::istream& in) {
  in.read((char*) &dim_, sizeof(dim_));
  in.read((char*) &nsubq_, sizeof(nsubq_));
  in.read((char*) &dsub_, sizeof(dsub_));
  in.read((char*) &lastdsub_, sizeof(lastdsub_));
  centroids_.resize(dim_ * ksub_);
  for (auto i=0; i < centroids_.size(); i++) {
    in.read((char*) &centroids_[i], sizeof(real));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rdi), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x24(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
leaq 0x30(%r14), %rdi
movslq 0x1c(%r14), %rax
movslq 0x4(%r14), %rsi
imulq %rax, %rsi
callq 0x886c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rax
subq %rsi, %rax
sarq $0x2, %rax
cmpq %r13, %rax
jbe 0xbaa1
addq %r12, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43e0
incq %r13
addq $0x4, %r12
jmp 0xba76
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::Matrix(fasttext::Matrix const&)
Matrix::Matrix(const Matrix& other) {
  m_ = other.m_;
  n_ = other.n_;
  data_ = new real[m_ * n_];
  for (int64_t i = 0; i < (m_ * n_); i++) {
    data_[i] = other.data_[i];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %r15
movq %r15, 0x10(%rdi)
imulq %rax, %r15
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %rcx
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x4030
movq %rax, (%r14)
movq (%rbx), %rcx
testq %r15, %r15
cmovleq %r12, %r15
cmpq %r12, %r15
je 0xbe88
movss (%rcx,%r12,4), %xmm0
movss %xmm0, (%rax,%r12,4)
incq %r12
jmp 0xbe72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::operator=(fasttext::Matrix const&)
Matrix& Matrix::operator=(const Matrix& other) {
  Matrix temp(other);
  m_ = temp.m_;
  n_ = temp.n_;
  std::swap(data_, temp.data_);
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xbe1e
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movq (%rbx), %rax
movq (%r14), %rcx
movq %rcx, (%rbx)
movq %rax, (%r14)
movq %r14, %rdi
callq 0xbed2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/matrix.cc
// Function: fasttext::Matrix::uniform(float)
void Matrix::uniform(real a) {
  std::minstd_rand rng(1);
  std::uniform_real_distribution<> uniform(-a, a);
  for (int64_t i = 0; i < (m_ * n_); i++) {
    data_[i] = uniform(rng);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movaps 0xede8(%rip), %xmm1     # 0x1ad00
xorps %xmm0, %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtps2pd %xmm1, %xmm0
movq $0x1, (%r14)
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
imulq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0xbf5f
movq %r15, %rdi
movq %r14, %rsi
callq 0x89a8
cvtsd2ss %xmm0, %xmm0
movq (%rbx), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
jmp 0xbf34
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop