LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xe0(%rdi), %r15
leaq 0xf0(%rdi), %rbp
movq %rbp, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movb %al, 0xf0(%rdi)
leaq 0x108(%rdi), %r12
leaq 0x118(%rdi), %r14
movq %r14, 0x108(%rdi)
movq %rax, 0x110(%rdi)
movb %al, 0x118(%rdi)
movabsq $0x3fa999999999999a, %rcx # imm = 0x3FA999999999999A
movq %rcx, 0x80(%rdi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x88(%rdi)
movaps 0x192ea(%rip), %xmm0    # 0x1e010
movups %xmm0, 0x94(%rdi)
movaps 0x192ec(%rip), %xmm0    # 0x1e020
movups %xmm0, 0xa8(%rdi)
movaps 0x192ee(%rip), %xmm0    # 0x1e030
movups %xmm0, 0xbc(%rdi)
movq %rax, 0xcc(%rdi)
movl $0xc, 0xd4(%rdi)
movl $0x64, 0x90(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xd8(%rdi)
leaq 0x192c4(%rip), %rcx     # 0x1e040
movl $0x9, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x44b0
movl $0x2, 0x100(%rbx)
movq 0x110(%rbx), %rdx
leaq 0x1aaa0(%rip), %rcx     # 0x1f846
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44b0
movl $0x0, 0x128(%rbx)
movl $0xffffffff, 0xa4(%rbx) # imm = 0xFFFFFFFF
movl $0x1, 0xb8(%rbx)
movw $0x0, 0x12c(%rbx)
movb $0x0, 0x12e(%rbx)
movq $0x0, 0x130(%rbx)
movq $0x2, 0x138(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x4e1f
movq (%r14), %rsi
incq %rsi
callq 0x4300
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x4e33
movq (%rbp), %rsi
incq %rsi
callq 0x4300
movq 0x60(%rbx), %rdi
cmpq %r13, %rdi
je 0x4e48
movq (%r13), %rsi
incq %rsi
callq 0x4300
movq 0x40(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x4e63
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4e7e
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x4e98
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rsp), %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x98(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xa0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xa8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xb0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xb4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xbc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xc0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xc4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xcc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xd0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x90(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
addq $0xd8, %r14
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x98(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xa0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xa8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xb0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xb4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xbc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xc0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xc4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xcc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xd0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x90(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
addq $0xd8, %r14
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x637a
movq (%rsi), %rax
movl $0x811c9dc5, %ebx       # imm = 0x811C9DC5
xorl %ecx, %ecx
movsbl (%rax,%rcx), %edx
xorl %ebx, %edx
imull $0x1000193, %edx, %ebx  # imm = 0x1000193
incq %rcx
cmpq %rcx, %r15
jne 0x634c
movl %ebx, %eax
shrl $0x7, %eax
imulq $0x11e54c7, %rax, %rax  # imm = 0x11E54C7
shrq $0x2a, %rax
imull $0x1c9c380, %eax, %eax  # imm = 0x1C9C380
subl %eax, %ebx
jmp 0x637f
movl $0x5da1c5, %ebx         # imm = 0x5DA1C5
movq 0x10(%rdi), %r12
movl %ebx, %eax
movl (%r12,%rax,4), %eax
cmpl $-0x1, %eax
je 0x63da
movq 0x28(%rdi), %r13
movq (%rsi), %r14
xorl %ebp, %ebp
cltq
leaq (%rax,%rax,8), %rax
movq 0x8(%r13,%rax,8), %rdx
cmpq %r15, %rdx
jne 0x63c6
testq %rdx, %rdx
je 0x63da
leaq (,%rax,8), %rax
addq %r13, %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4320
testl %eax, %eax
je 0x63da
incl %ebx
cmpl $0x1c9c380, %ebx        # imm = 0x1C9C380
cmovel %ebp, %ebx
movl (%r12,%rbx,4), %eax
cmpl $-0x1, %eax
jne 0x6397
movl %ebx, %eax
addq $0x8, %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/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 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x6414
movq (%rsi), %rdx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %esi, %esi
movsbl (%rdx,%rsi), %edi
xorl %eax, %edi
imull $0x1000193, %edi, %eax  # imm = 0x1000193
incq %rsi
cmpq %rsi, %rcx
jne 0x63ff
retq
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x632e
incq 0x68(%rbx)
movl %eax, %r13d
movq 0x10(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq $-0x1, %rax
je 0x6459
movq 0x28(%rbx), %rcx
leaq (%rax,%rax,8), %rax
incq 0x20(%rcx,%rax,8)
jmp 0x6505
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movq %rax, 0x30(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x41a0
leaq 0x8(%rsp), %r15
movq $0x1, 0x20(%r15)
movq (%rbx), %rax
movq 0xe0(%rax), %rsi
movq 0xe8(%rax), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x45a0
testq %rax, %rax
sete 0x28(%r15)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0xa4de
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
movq 0x10(%rbx), %rcx
movl %eax, (%rcx,%r13,4)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x64ee
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6505
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa508
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x632e
movq 0x10(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %esi
testl %esi, %esi
js 0x65fc
movq %r14, %rdi
callq 0x655e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa53c
jmp 0x66b9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x23d7f(%rip), %rsi     # 0x2a390
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0xa5bc
movq 0x23d8b(%rip), %rsi     # 0x2a3b0
movq 0x23d8c(%rip), %rdx     # 0x2a3b8
leaq 0x20(%rsp), %rdi
callq 0x4100
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x665c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6663
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6734
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x669e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66b9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x66e4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x66e4
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6704
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x6704
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6718
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x30(%rsp)
cmpq $0x0, 0x8(%rsi)
je 0x68a5
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq %r13, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq (%r14), %rax
movb (%rax,%rbx), %al
andb $-0x40, %al
negb %al
jo 0x687c
cmpq 0x8(%r14), %rbx
jae 0x687c
movl $0x1, %ebp
movq %rbx, %r13
movq (%r15), %rax
movslq 0xd0(%rax), %rax
cmpq %rax, %rbp
ja 0x687c
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movq %r12, %rdi
callq 0x4290
incq %r13
movq 0x8(%r14), %rax
cmpq %rax, %r13
jae 0x67e8
movq (%r14), %rcx
movb (%rcx,%r13), %cl
movl %ecx, %edx
andb $-0x40, %dl
negb %dl
jno 0x67e8
incq %r13
movsbl %cl, %esi
movq %r12, %rdi
callq 0x4290
jmp 0x67bf
movq (%r15), %rcx
movslq 0xcc(%rcx), %rdx
cmpq %rdx, %rbp
jb 0x686f
testq %rbx, %rbx
sete %dl
cmpq %rax, %r13
sete %al
cmpq $0x1, %rbp
jne 0x680d
orb %al, %dl
jne 0x686f
movq 0x18(%rsp), %rdx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
testq %rdx, %rdx
je 0x683a
movq 0x10(%rsp), %rsi
xorl %edi, %edi
movsbl (%rsi,%rdi), %r8d
xorl %eax, %r8d
imull $0x1000193, %r8d, %eax  # imm = 0x1000193
incq %rdi
cmpq %rdi, %rdx
jne 0x6823
xorl %edx, %edx
divl 0xc4(%rcx)
addl 0x5c(%r15), %edx
movl %edx, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6865
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x686f
leaq 0xc(%rsp), %rdx
callq 0xb088
incq %rbp
cmpq 0x8(%r14), %r13
jb 0x6799
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %r13
cmpq %r13, %rdi
je 0x6898
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
incq %rbx
cmpq 0x8(%r14), %rbx
jb 0x6764
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68b8
jmp 0x68b8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x68d7
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/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x632e
movq 0x10(%r15), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
movl %eax, 0xc(%rsp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x6918
movq %rax, 0x8(%r14)
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0xacd2
movl 0xc(%rsp), %eax
testl %eax, %eax
js 0x6941
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x6963
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x6970
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x6983
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x6990
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0xad24
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x28(%r15), %rsi
jmp 0x6993
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xb088
movq %r12, %rsi
movq %rbx, %rdi
callq 0xa616
leaq 0x239ee(%rip), %rsi     # 0x2a390
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0xa5bc
movq 0x239f7(%rip), %rsi     # 0x2a3b0
movq 0x239f8(%rip), %rdx     # 0x2a3b8
movq %r13, %rdi
callq 0x4100
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x69f0
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x69f8
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x10(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6aa4
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a39
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a54
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a81
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x6a81
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a9c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c93
cmpl %esi, 0x5c(%rdi)
jle 0x6cb2
movq (%rdi), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x6c84
xorl %eax, %eax
jmp 0x6c91
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0x17f0f(%rip), %rdi     # 0x1eba9
leaq 0x17c9e(%rip), %rsi     # 0x1e93f
leaq 0x17d00(%rip), %rcx     # 0x1e9a8
movl $0x62, %edx
callq 0x41d0
leaq 0x17d27(%rip), %rdi     # 0x1e9e0
leaq 0x17c7f(%rip), %rsi     # 0x1e93f
leaq 0x17ce1(%rip), %rcx     # 0x1e9a8
movl $0x63, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
cmpq %r15, %r14
je 0x6dd7
cmpb $0x0, 0x28(%r14)
jne 0x6dd1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa616
addq $0x48, %r14
jmp 0x6dba
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa654
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x58(%rdi)
je 0x6fd1
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movl $0x30, %ebp
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rbp), %rdx
addq $-0x30, %rdx
movq %r15, %rdi
leaq 0x234a4(%rip), %rsi     # 0x2a390
callq 0xa5bc
movq 0x234b8(%rip), %rsi     # 0x2a3b0
movq 0x234b9(%rip), %rdx     # 0x2a3b8
movq %r15, %rdi
callq 0x4100
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6f2a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6f32
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6f66
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x28(%rbx), %rdi
movl %r14d, 0x28(%rsp)
movq 0x8(%rdi,%rbp), %rsi
cmpq 0x10(%rdi,%rbp), %rsi
je 0x6f89
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi,%rbp)
jmp 0x6f94
addq %rbp, %rdi
movq %r15, %rdx
callq 0xb088
movq 0x28(%rbx), %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6734
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6fbd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
incq %r14
movslq 0x58(%rbx), %rax
addq $0x48, %rbp
cmpq %rax, %r14
jb 0x6ed6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ffb
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x7015
movq 0x38(%rsp), %rsi
jmp 0x700d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7015
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rbx
movq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq 0x10(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
jae 0x70c2
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rbx)
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x70cd
movl %eax, %edx
andl $0xfb, %edx
cmpl $0x9, %edx
jne 0x7087
cmpq $0x0, 0x8(%r14)
jne 0x70e0
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x7048
jmp 0x70fe
cmpl $0xaffffff, %ecx        # imm = 0xAFFFFFF
jle 0x70a9
cmpl $0xb000000, %ecx        # imm = 0xB000000
je 0x7076
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x7076
cmpl $0xc000000, %ecx        # imm = 0xC000000
je 0x7076
jmp 0x70b5
testl %ecx, %ecx
je 0x7076
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x7076
movsbl %al, %esi
movq %r14, %rdi
callq 0x4290
jmp 0x7048
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
jmp 0x705c
movq %r15, %rdi
callq 0x4370
cmpq $0x0, 0x8(%r14)
setne %bpl
jmp 0x7117
movb $0x1, %bpl
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x7117
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
jae 0x7124
decq %rax
movq %rax, 0x10(%rbx)
jmp 0x7117
movq 0x2326b(%rip), %rsi     # 0x2a370
movq 0x2326c(%rip), %rdx     # 0x2a378
movq %r14, %rdi
callq 0x4100
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x46a0
jmp 0x7117
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa6ec
cmpl $0x0, 0x58(%rbx)
je 0x7af3
movl $0x8, %r14d
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movq 0x28(%rbx), %rax
xorps %xmm1, %xmm1
cvtsi2ssq (%rax,%r14,4), %xmm1
xorps %xmm0, %xmm0
cvtsi2ssq 0x68(%rbx), %xmm0
movq (%rbx), %rax
divss %xmm0, %xmm1
movsd 0xd8(%rax), %xmm0
xorps %xmm3, %xmm3
cvtss2sd %xmm1, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jb 0x7aa6
sqrtsd %xmm0, %xmm0
jmp 0x7abb
movsd %xmm3, 0x8(%rsp)
callq 0x4250
movsd 0x8(%rsp), %xmm3
xorpd %xmm2, %xmm2
movq (%rbx), %rax
movq 0x40(%rbx), %rcx
movsd 0xd8(%rax), %xmm1
divsd %xmm3, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rcx,%r15,4)
incq %r15
movslq 0x58(%rbx), %rax
addq $0x12, %r14
cmpq %rax, %r15
jb 0x7a6a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
cmpq %r15, %r14
je 0x7b64
movl %edx, %ebp
addq $0x20, %r14
cmpb %bpl, 0x8(%r14)
jne 0x7b54
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7b49
movq (%r14), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7b54
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb8de
leaq 0x48(%r14), %rax
addq $0x28, %r14
cmpq %r15, %r14
movq %rax, %r14
jne 0x7b29
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7b89
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, (%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x70(%rdi)
je 0x7d2d
movq %rdx, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x7d2d
movq %rdi, %r12
leaq 0x78(%rdi), %rcx
movq %rcx, 0x20(%rsp)
movslq (%rsp), %rcx
movq %rcx, 0x28(%rsp)
movl $0x2, %ecx
movq %rcx, 0x18(%rsp)
movabsq $0x200000000, %rcx      # imm = 0x200000000
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
cmpl $0x2, (%rsp)
setl %dil
movq %rcx, %r9
leaq 0x1(%rcx), %r8
movq (%r15), %rcx
movq 0x8(%r15), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
movq %r8, 0x30(%rsp)
cmpq %r8, %rsi
setbe %sil
orb %dil, %sil
jne 0x7cfa
movslq (%rax,%r9,4), %rbx
addq 0x28(%rsp), %r9
movq %r9, 0x40(%rsp)
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r14
imulq $0x6eac5db, %rbx, %rax  # imm = 0x6EAC5DB
movslq -0x4(%rcx,%r14,4), %rbx
addq %rax, %rbx
movq (%r12), %rax
movslq 0xc4(%rax), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rbp
cmpq $0x0, 0x70(%r12)
jle 0x7c97
movl %ebp, 0xc(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0xba1a
testq %rax, %rax
je 0x7cc5
movl %ebp, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xba94
movl (%rax), %ebp
addl 0x5c(%r12), %ebp
movl %ebp, 0x4(%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7cbb
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x7cc5
leaq 0x4(%rsp), %rdx
callq 0xb088
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %r14, %rax
jbe 0x7cfa
movq %r13, %rax
sarq $0x20, %rax
incq %r14
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %r13
cmpq 0x40(%rsp), %rax
jl 0x7c3d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
incq 0x18(%rsp)
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, 0x10(%rsp)
movq 0x30(%rsp), %rsi
cmpq %rsi, %rcx
movq %rsi, %rcx
ja 0x7bf3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/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 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x2, %rax
movq %rax, 0x10(%rsp)
testl %eax, %eax
jle 0x83b4
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x28(%rsp)
movl $0x1, %eax
movq %rax, 0x20(%rsp)
xorl %ecx, %ecx
movq 0x18(%rsp), %rax
movl %eax, %ebp
movq 0x10(%rsp), %rdx
cmpl %edx, %ebp
movl %edx, %r12d
cmovll %ebp, %r12d
movq %rcx, %rax
leaq 0x1(%rcx), %rsi
movq 0x18(%rsp), %rcx
addl %eax, %ecx
cmpl %ecx, %edx
cmovll %edx, %ecx
movslq %ecx, %rcx
movq %rsi, 0x30(%rsp)
cmpq %rcx, %rsi
jge 0x839d
movq (%r14), %rcx
movslq (%rcx,%rax,4), %r13
movq 0x20(%rsp), %rbx
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 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8388
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x8395
movq %r14, %rdi
leaq 0xc(%rsp), %rdx
callq 0xb088
incq %rbx
cmpq %rbx, %r12
jne 0x8347
incq 0x20(%rsp)
incl %ebp
movq 0x30(%rsp), %rcx
cmpq 0x28(%rsp), %rcx
jne 0x830d
addq $0x38, %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/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 $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
movq %rsi, 0x50(%rsp)
callq 0x43f0
leaq 0x5c(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x60(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x68(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x70(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x43f0
movq %r14, (%rsp)
cmpl $0x0, 0x58(%r14)
jle 0x8931
leaq 0x28(%rsp), %r12
movl $0x30, %r15d
xorl %r13d, %r13d
movq (%rsp), %rax
movq 0x28(%rax), %r14
leaq (%r14,%r15), %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq -0x30(%r14,%r15), %rsi
movq -0x28(%r14,%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa8dc
movb -0x8(%r14,%r15), %al
movb %al, 0x8(%r12)
movq -0x10(%r14,%r15), %rax
movq %rax, (%r12)
leaq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0xa53c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4040
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x43f0
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
callq 0x43f0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x88fd
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8919
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
incq %r13
movq 0x50(%rsp), %rax
movslq (%rax), %rax
addq $0x48, %r15
cmpq %rax, %r13
jl 0x885b
movq (%rsp), %rax
movq 0x88(%rax), %r12
testq %r12, %r12
je 0x897e
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x8(%r12), %rax
movq %rax, 0x8(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43f0
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43f0
movq (%r12), %r12
testq %r12, %r12
jne 0x894b
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x89bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x89bb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa508
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edx, %edx
jle 0xcca6
movl %edx, %eax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm1
subss (%rsi,%rcx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xcc8b
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %r8d, %eax
xorps %xmm0, %xmm0
testl %r8d, %r8d
jle 0xcde6
xorl %r9d, %r9d
movss (%rsi,%r9,4), %xmm1
subss (%rdx,%r9,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %r9
cmpq %r9, %rax
jne 0xcdca
movb $0x0, (%rcx)
cmpl $0x2, 0x4(%rdi)
jl 0xce3e
movslq %r8d, %r9
leaq (%rdx,%r9,4), %rdx
shlq $0x2, %r9
movl $0x1, %r10d
xorps %xmm1, %xmm1
testl %r8d, %r8d
jle 0xce27
xorl %r11d, %r11d
movss (%rsi,%r11,4), %xmm2
subss (%rdx,%r11,4), %xmm2
mulss %xmm2, %xmm2
addss %xmm2, %xmm1
incq %r11
cmpq %r11, %rax
jne 0xce0b
ucomiss %xmm1, %xmm0
jbe 0xce32
movb %r10b, (%rcx)
movaps %xmm1, %xmm0
incl %r10d
addq %r9, %rdx
cmpl 0x4(%rdi), %r10d
jl 0xce00
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdx, 0x28(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movl %ecx, (%rsp)
movslq %ecx, %rsi
leaq 0x54(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x38(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %rsi, 0x18(%rsp)
callq 0xd97e
movq (%r14), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xd19a
xorl %eax, %eax
movq %rdi, %rcx
movl %eax, (%rcx)
incl %eax
addq $0x4, %rcx
cmpq %rsi, %rcx
jne 0xd18d
leaq 0x48(%rbp), %rdx
callq 0xd9fb
cmpl $0x0, 0x4(%rbp)
movslq %ebx, %rax
movq %rax, 0x8(%rsp)
jle 0xd20d
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
leaq (,%rax,4), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq 0x28(%rsp), %r14
movq 0x20(%rsp), %rax
movslq (%rax,%r13,4), %rax
imulq 0x8(%rsp), %rax
leaq (%r12,%rax,4), %rsi
movq %r14, %rdi
movq %r12, %r15
movq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x4260
incq %r13
movslq 0x4(%rbp), %rax
addq %r12, %r14
movq %r15, %r12
cmpq %rax, %r13
jl 0xd1d5
movq %r12, 0x30(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4030
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x14(%rbp)
jle 0xd2bd
movq %rbp, %r12
movl (%rsp), %eax
movq %rax, 0x18(%rsp)
shlq $0x2, 0x8(%rsp)
xorl %eax, %eax
movq 0x28(%rsp), %rbp
movl %eax, 0x20(%rsp)
cmpl $0x0, (%rsp)
movl %ebx, %eax
movq 0x8(%rsp), %rcx
jle 0xd292
movq 0x30(%rsp), %r14
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rbx
movq %rcx, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movl %eax, %r15d
movl %eax, %r8d
callq 0xcdbc
movq 0x8(%rsp), %rcx
movl %r15d, %eax
incq %r13
addq %rcx, %r14
decq %rbx
jne 0xd268
movq %r12, %rdi
movq 0x30(%rsp), %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movl %eax, %ebx
movl %eax, %r8d
movl (%rsp), %r9d
callq 0xce9e
movl 0x20(%rsp), %eax
incl %eax
cmpl 0x14(%r12), %eax
jl 0xd243
movq 0x10(%rsp), %rdi
callq 0x43e0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xd2de
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd2f1
jmp 0xd2f1
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xd30b
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movl 0x20(%rdi), %ebx
testl %ebx, %ebx
jle 0xd61f
movq %rsi, %r14
movq %rdi, %r15
imull %ebx, %ecx
movslq %ecx, %rax
addq %rax, %rdx
movl 0x24(%rdi), %ebp
xorps %xmm0, %xmm0
xorl %r12d, %r12d
movq %rdx, 0x18(%rsp)
movss %xmm0, 0xc(%rsp)
movzbl (%rdx,%r12), %edx
movq %r15, %rdi
movl %r12d, %esi
callq 0xcd50
movq %rax, %r13
decl %ebx
cmpq %rbx, %r12
jne 0xd59a
movl 0x28(%r15), %ebp
testl %ebp, %ebp
movl %ebp, 0x14(%rsp)
movq %r12, 0x20(%rsp)
jle 0xd5f9
movl %ebp, %ebx
movslq %r12d, %rbp
xorl %r12d, %r12d
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movslq 0x24(%r15), %rsi
imulq %rbp, %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0xf3dc
movss (%rax), %xmm0
mulss (%r13,%r12,4), %xmm0
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
incq %r12
cmpq %r12, %rbx
jne 0xd5b5
jmp 0xd5ff
movss 0xc(%rsp), %xmm0
movq 0x20(%rsp), %r12
incq %r12
movslq 0x20(%r15), %rbx
cmpq %rbx, %r12
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ebp
jl 0xd576
jmp 0xd622
xorps %xmm0, %xmm0
mulss 0x10(%rsp), %xmm0
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/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 %rdx, 0x18(%rsp)
movl 0x20(%rdi), %ebx
testl %ebx, %ebx
jle 0xd711
movq %rsi, %r14
movq %rdi, %r15
imull %ebx, %ecx
movslq %ecx, %rax
addq %rax, 0x18(%rsp)
movl 0x24(%rdi), %eax
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
movzbl (%rax,%r12), %edx
movq %r15, %rdi
movl %r12d, %esi
callq 0xcd50
movq %rax, %r13
decl %ebx
movq %r12, 0x20(%rsp)
cmpq %rbx, %r12
jne 0xd6a3
movl 0x28(%r15), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
jle 0xd6fc
movl 0xc(%rsp), %ebx
movslq 0x20(%rsp), %rbp
xorl %r12d, %r12d
movslq 0x24(%r15), %rsi
imulq %rbp, %rsi
addq %r12, %rsi
movss (%r13,%r12,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movq %r14, %rdi
callq 0xf3ce
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
addss (%rax), %xmm1
movss %xmm1, (%rax)
incq %r12
cmpq %r12, %rbx
jne 0xd6bc
movq 0x20(%rsp), %r12
incq %r12
movslq 0x20(%r15), %rbx
cmpq %rbx, %r12
jl 0xd677
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/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:
movl 0x20(%rdi), %eax
testl %eax, %eax
jle 0xd78a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x24(%rdi), %ebp
xorl %r12d, %r12d
decl %eax
cmpq %rax, %r12
jne 0xd749
movl 0x28(%r15), %ebp
movl 0x24(%r15), %eax
imull %r12d, %eax
cltq
leaq (%r14,%rax,4), %rsi
imull 0x4(%r15), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
addq 0x30(%r15), %rdx
leaq (%rbx,%r12), %rcx
movq %r15, %rdi
movl %ebp, %r8d
callq 0xcdbc
incq %r12
movslq 0x20(%r15), %rax
cmpq %rax, %r12
jl 0xd73e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x20(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x24(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x28(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x20(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x24(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x28(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x30(%r14), %rdi
movslq 0x1c(%r14), %rax
movslq 0x4(%r14), %rsi
imulq %rax, %rsi
callq 0xa6ec
movq 0x30(%r14), %rsi
cmpq %rsi, 0x38(%r14)
je 0xd8e8
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
incq %r12
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rax
subq %rsi, %rax
sarq $0x2, %rax
addq $0x4, %r15
cmpq %r12, %rax
ja 0xd8bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
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 %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x4030
movq %rax, (%r14)
testq %r15, %r15
jle 0xdd93
movq (%rbx), %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0xdd81
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdd36
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
movq (%r14), %rax
movq %rax, (%rbx)
movq %rdi, (%r14)
testq %rdi, %rdi
je 0xddd5
callq 0x43e0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq