LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5600
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5600
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5600
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5600
movq -0x28(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x20(%rbp)
callq 0x5600
movq -0x28(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x30(%rbp)
callq 0x5600
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movabsq $0x3fa999999999999a, %rcx # imm = 0x3FA999999999999A
movq %rcx, 0x80(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x88(%rax)
movl $0x64, 0x94(%rax)
movl $0x5, 0x98(%rax)
movl $0x0, 0x9c(%rax)
movl $0x5, 0xa0(%rax)
movl $0x5, 0xa8(%rax)
movl $0x0, 0xac(%rax)
movl $0x5, 0xb0(%rax)
movl $0x1, 0xb4(%rax)
movl $0x2, 0xbc(%rax)
movl $0x2, 0xc0(%rax)
movl $0x1e8480, 0xc4(%rax)   # imm = 0x1E8480
movl $0x1, 0xc8(%rax)
movl $0x0, 0xcc(%rax)
movl $0x0, 0xd0(%rax)
movl $0xc, 0xd4(%rax)
movl $0x64, 0x90(%rax)
movabsq $0x3f1a36e2eb1c432d, %rcx # imm = 0x3F1A36E2EB1C432D
movq %rcx, 0xd8(%rax)
leaq 0x3c193(%rip), %rsi     # 0x42010
callq 0x55e0
jmp 0x5e84
movq -0x50(%rbp), %rdi
movl $0x2, 0x100(%rdi)
addq $0x108, %rdi            # imm = 0x108
leaq 0x3d946(%rip), %rsi     # 0x437e6
callq 0x55e0
jmp 0x5ea7
movq -0x50(%rbp), %rax
movl $0x0, 0x128(%rax)
movl $0xffffffff, 0xa4(%rax) # imm = 0xFFFFFFFF
movl $0x1, 0xb8(%rax)
movb $0x0, 0x12c(%rax)
movb $0x0, 0x12d(%rax)
movb $0x0, 0x12e(%rax)
movq $0x0, 0x130(%rax)
movq $0x2, 0x138(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x58d8
movq -0x20(%rbp), %rdi
callq 0x58d8
movq -0x38(%rbp), %rdi
callq 0x58d8
movq -0x40(%rbp), %rdi
callq 0x58d8
movq -0x48(%rbp), %rdi
callq 0x58d8
movq -0x28(%rbp), %rdi
callq 0x58d8
movq -0x10(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x98, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa8, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb4, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xbc, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc4, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xcc, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x90, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd8, %rsi
movl $0x8, %edx
callq 0x55b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x98, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa8, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb4, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xbc, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc4, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xcc, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x90, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd8, %rsi
movl $0x8, %edx
callq 0x5540
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8120
movl $0x1c9c380, %ecx        # imm = 0x1C9C380
xorl %edx, %edx
divl %ecx
movl %edx, -0x14(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe1d0
movq %rax, %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x21(%rbp)
je 0x80f2
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe1d0
movq -0x30(%rbp), %rdi
movslq (%rax), %rsi
callq 0xe220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xe1f0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x80fb
jmp 0x810e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x1c9c380, %ecx        # imm = 0x1C9C380
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x809d
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x811c9dc5, -0x14(%rbp) # imm = 0x811C9DC5
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x8195
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x54a0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
imull $0x1000193, -0x14(%rbp), %eax # imm = 0x1000193
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x813f
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8070
movq -0x78(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq 0x68(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x68(%rdi)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe240
cmpl $-0x1, (%rax)
jne 0x828c
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xe260
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5070
jmp 0x8209
movq -0x78(%rbp), %rdi
movq $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x82e0
movb %al, -0x81(%rbp)
jmp 0x8226
movq -0x78(%rbp), %rdi
movb -0x81(%rbp), %al
movb %al, -0x38(%rbp)
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
callq 0xe290
jmp 0x8242
movq -0x78(%rbp), %rdi
movl 0x58(%rdi), %eax
movl %eax, -0x88(%rbp)
addl $0x1, %eax
movl %eax, 0x58(%rdi)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe240
movl -0x88(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x60(%rbp), %rdi
callq 0xe300
jmp 0x82c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe300
jmp 0x82cf
movq -0x78(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x90(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe240
movq -0x90(%rbp), %rdi
movslq (%rax), %rsi
callq 0xe330
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x57a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x18(%rbp), %rsi
callq 0x8570
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x848f
movq -0x78(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x83a0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xe350
jmp 0x8557
movq -0x88(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0xe440
movq -0x18(%rbp), %rdx
leaq 0x57006(%rip), %rsi     # 0x5f4b0
leaq -0x60(%rbp), %rdi
callq 0xe4b0
jmp 0x84b5
leaq 0x57014(%rip), %rdx     # 0x5f4d0
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xe460
jmp 0x84cb
movq -0x88(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x85b0
jmp 0x84e1
leaq -0x40(%rbp), %rdi
callq 0x58d8
leaq -0x60(%rbp), %rdi
callq 0x58d8
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x8547
jmp 0x853b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8549
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x58d8
leaq -0x60(%rbp), %rdi
callq 0x58d8
jmp 0x8549
movq -0x88(%rbp), %rdi
callq 0xe530
jmp 0x8557
movq -0x88(%rbp), %rdi
callq 0xe530
jmp 0x8564
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x57a0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8570
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe590
movq -0x20(%rbp), %rdi
callq 0xe5b0
cmpl $0x0, -0x24(%rbp)
jl 0x88f1
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xe5d0
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x28, %rdi
movslq -0x24(%rbp), %rsi
callq 0xe220
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xe640
jmp 0x8912
movq -0x18(%rbp), %rdi
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rsi
callq 0xe6b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe640
movq -0x10(%rbp), %rdx
leaq 0x56b93(%rip), %rsi     # 0x5f4b0
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xe4b0
movq -0x90(%rbp), %rsi
leaq 0x56b95(%rip), %rdx     # 0x5f4d0
leaq -0x48(%rbp), %rdi
callq 0xe460
jmp 0x8946
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rsi
callq 0x89b0
jmp 0x895d
leaq -0x48(%rbp), %rdi
callq 0x58d8
leaq -0x68(%rbp), %rdi
callq 0x58d8
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x899b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x58d8
leaq -0x68(%rbp), %rdi
callq 0x58d8
movq -0x70(%rbp), %rdi
callq 0x57a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x8cb4
jmp 0x8cd3
leaq 0x39ecd(%rip), %rdi     # 0x42b88
leaq 0x39c5c(%rip), %rsi     # 0x4291e
movl $0x62, %edx
leaq 0x39cb9(%rip), %rcx     # 0x42987
callq 0x52d0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x8ce1
jmp 0x8d00
leaq 0x39cd7(%rip), %rdi     # 0x429bf
leaq 0x39c2f(%rip), %rsi     # 0x4291e
movl $0x63, %edx
leaq 0x39c8c(%rip), %rcx     # 0x42987
callq 0x52d0
movq -0x20(%rbp), %rdi
callq 0xe6e0
cmpl $0x4, 0xc0(%rax)
jne 0x8d18
movb $0x0, -0x1(%rbp)
jmp 0x8d43
movq -0x20(%rbp), %rdi
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe700
movss -0x24(%rbp), %xmm0
ucomiss (%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe720
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe740
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe770
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7a0
testb $0x1, %al
jne 0x8ef5
jmp 0x8f41
leaq -0x28(%rbp), %rdi
callq 0xe7e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, 0x28(%rax)
jne 0x8f34
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xe640
jmp 0x8f1b
jmp 0x8f34
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe820
jmp 0x8f5e
jmp 0x8f36
leaq -0x28(%rbp), %rdi
callq 0xe800
jmp 0x8ee2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8f54
movq -0x60(%rbp), %rdi
callq 0xe820
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x58(%rcx), %rcx
cmpq %rcx, %rax
jae 0x91a0
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
movq %rax, %rdx
leaq 0x563d4(%rip), %rsi     # 0x5f4b0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xe4b0
movq -0x70(%rbp), %rsi
leaq 0x563dc(%rip), %rdx     # 0x5f4d0
leaq -0x30(%rbp), %rdi
callq 0xe460
jmp 0x90ff
leaq -0x50(%rbp), %rdi
callq 0x58d8
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
movq %rax, %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xe6b0
jmp 0x9131
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
movq -0x68(%rbp), %rdi
movq %rax, %rdx
addq $0x30, %rdx
leaq -0x30(%rbp), %rsi
callq 0x85b0
jmp 0x9158
leaq -0x30(%rbp), %rdi
callq 0x58d8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x90ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x58d8
jmp 0x91a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x58d8
jmp 0x91a6
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x57a0
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x51f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x55a0
movq -0x30(%rbp), %rdi
callq 0x5250
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x9295
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0xd, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0x9, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0xb, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0xc, %eax
je 0x9238
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x9283
movq -0x20(%rbp), %rdi
callq 0x5710
testb $0x1, %al
jne 0x9247
jmp 0x926b
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x9266
movq -0x20(%rbp), %rdi
leaq 0x56235(%rip), %rsi     # 0x5f490
callq 0x5570
movb $0x1, -0x1(%rbp)
jmp 0x92ae
jmp 0x91e1
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x927d
movq -0x30(%rbp), %rdi
callq 0x5290
movb $0x1, -0x1(%rbp)
jmp 0x92ae
movq -0x20(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x53c0
jmp 0x91e1
movq -0x18(%rbp), %rdi
callq 0x54e0
movq -0x20(%rbp), %rdi
callq 0x5710
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::truncate(long)
void Dictionary::truncate(int64_t maxVocabSize) {
  if (maxVocabSize >= words_.size())
      return;
  sort(words_.begin(), words_.end(), [](const entry& e1, const entry& e2) {
    if (e1.type != e2.type) return e1.type < e2.type;
    return e1.count > e2.count;
  });
  words_.resize(maxVocabSize);
  words_.shrink_to_fit();
  size_ = 0;
  nwords_ = 0;
  nlabels_ = 0;
  std::fill(word2int_.begin(), word2int_.end(), -1);
  for (auto it = words_.begin(); it != words_.end(); ++it) {
    int32_t h = find(it->word);
    word2int_[h] = size_++;
    if (it->type == entry_type::word) nwords_++;
    if (it->type == entry_type::label) nlabels_++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
callq 0xeaf0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jb 0x9b0a
jmp 0x9c60
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
callq 0xe880
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0xe8b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9e10
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xeb20
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
callq 0xe9b0
movq -0x68(%rbp), %rdi
movl $0x0, 0x58(%rdi)
movl $0x0, 0x5c(%rdi)
movl $0x0, 0x60(%rdi)
addq $0x10, %rdi
callq 0xea10
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0xea40
movq %rax, -0x38(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xe9d0
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
callq 0xe880
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
callq 0xe8b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xea70
testb $0x1, %al
jne 0x9bde
jmp 0x9c60
leaq -0x48(%rbp), %rdi
callq 0xeab0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x8070
movq -0x68(%rbp), %rdi
movl %eax, -0x54(%rbp)
movl 0x58(%rdi), %eax
movl %eax, -0x6c(%rbp)
addl $0x1, %eax
movl %eax, 0x58(%rdi)
addq $0x10, %rdi
movslq -0x54(%rbp), %rsi
callq 0xe240
movl -0x6c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0xeab0
cmpb $0x0, 0x28(%rax)
jne 0x9c34
movq -0x68(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
leaq -0x48(%rbp), %rdi
callq 0xeab0
cmpb $0x1, 0x28(%rax)
jne 0x9c50
movq -0x68(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
jmp 0x9c52
leaq -0x48(%rbp), %rdi
callq 0xead0
jmp 0x9bb7
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x58(%rax), %rsi
callq 0xebb0
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x58(%rcx), %rcx
cmpq %rcx, %rax
jae 0x9d5a
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
movq -0x20(%rbp), %rdi
cvtsi2ssq 0x20(%rax), %xmm0
cvtsi2ssq 0x68(%rdi), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
callq 0xe6e0
movsd 0xd8(%rax), %xmm0
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x5370
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
callq 0xe6e0
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
movsd 0xd8(%rax), %xmm1
movss -0x14(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0xec40
movss -0x24(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9c9c
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x12(%rbp)
callq 0xec60
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe740
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe770
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7a0
testb $0x1, %al
jne 0x9eba
jmp 0x9f0c
leaq -0x28(%rbp), %rdi
callq 0xe7e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb 0x28(%rax), %al
cmpb -0x11(%rbp), %al
jne 0x9eff
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0xec80
jmp 0x9ee6
jmp 0x9eff
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xecf0
jmp 0x9f29
jmp 0x9f01
leaq -0x28(%rbp), %rdi
callq 0xe800
jmp 0x9ea7
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x9f1f
movq -0x60(%rbp), %rdi
callq 0xecf0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x70(%rax)
jne 0x9f6e
jmp 0xa0cc
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0xed50
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0xa0cc
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xe1d0
movslq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0xed50
movq -0x68(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x59(%rbp)
jae 0x9fe6
movl -0x2c(%rbp), %eax
movl -0x20(%rbp), %ecx
addl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x9ff2
jmp 0xa0bc
imulq $0x6eac5db, -0x28(%rbp), %rax # imm = 0x6EAC5DB
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xe1d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x78(%rbp), %rax
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0xe6e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movslq 0xc4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq -0x50(%rbp), %rax
movq %rdx, -0x38(%rbp)
cmpq $0x0, 0x70(%rax)
jle 0xa092
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
movq -0x38(%rbp), %rax
movl %eax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0xed70
cmpq $0x0, %rax
je 0xa08e
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
movq -0x38(%rbp), %rax
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xeda0
movslq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa090
jmp 0xa0ae
jmp 0xa092
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq 0x5c(%rax), %rax
addq -0x38(%rbp), %rax
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0xe6b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9fb3
jmp 0xa0be
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9f75
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed50
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa934
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xe240
movslq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0xa895
movl -0x2c(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa8a1
jmp 0xa924
imulq $0x6eac5db, -0x28(%rbp), %rax # imm = 0x6EAC5DB
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xe240
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq 0x5c(%rdi), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xe6e0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
movslq 0xc4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq -0x48(%rbp), %rax
addq %rdx, %rax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xe6b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa877
jmp 0xa926
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa84e
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x5c, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x68, %rsi
movl $0x8, %edx
callq 0x55b0
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x70, %rsi
movl $0x8, %edx
callq 0x55b0
movl $0x0, -0x14(%rbp)
movq -0x98(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0xaf3d
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe220
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xf1a0
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x52a0
movq -0xb0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x5300
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x55b0
jmp 0xaed7
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5050
jmp 0xaee4
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x8, %edx
callq 0x55b0
jmp 0xaef8
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x55b0
jmp 0xaf0c
leaq -0x60(%rbp), %rdi
callq 0xe300
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xae5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe300
jmp 0xafd4
movq -0x98(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0xf210
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0xf240
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xf270
testb $0x1, %al
jne 0xaf7f
jmp 0xafcb
leaq -0x80(%rbp), %rdi
callq 0xf2a0
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
addq $0x4, %rsi
movl $0x4, %edx
callq 0x55b0
leaq -0x80(%rbp), %rdi
callq 0xf2d0
jmp 0xaf69
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x57a0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1bf2c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bede
movss -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1bec0
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x38(%rbp)
movq -0x48(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x1c256
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1bec0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1c249
movl -0x38(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x1c24b
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1c1ef
movss -0x34(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl 0x24(%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rcx), %ecx
imull -0x1c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x1ce6c
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %edx
callq 0x1c080
movq -0x50(%rbp), %rcx
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1ce05
movq -0x50(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1ce5c
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
imull 0x24(%rcx), %eax
addl -0x44(%rbp), %eax
movslq %eax, %rsi
callq 0x21410
movss (%rax), %xmm0
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x24(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1ce0c
jmp 0x1ce5e
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1cdbe
movss -0x24(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl 0x24(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rcx), %ecx
imull -0x1c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x1cf87
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %edx
callq 0x1c080
movq -0x50(%rbp), %rcx
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1cf0d
movq -0x50(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1cf77
movq -0x50(%rbp), %rcx
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rdx
movss (%rax,%rdx,4), %xmm0
movss %xmm0, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
imull 0x24(%rcx), %eax
addl -0x44(%rbp), %eax
movslq %eax, %rsi
callq 0x213e0
movss -0x58(%rbp), %xmm0
movss -0x54(%rbp), %xmm2
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1cf14
jmp 0x1cf79
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1cec6
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x1d031
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1cfe0
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull 0x24(%rdi), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %esi
xorl %edx, %edx
callq 0x1c080
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rax
addq %rax, %rcx
movl -0x1c(%rbp), %r8d
callq 0x1c1a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1cfb9
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x24, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x1d680
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x30, %rdi
callq 0x14310
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
shlq $0x2, %rdx
callq 0x55b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x24, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x20(%rbp), %rcx
movq %rcx, %rdi
addq $0x30, %rdi
movl 0x1c(%rcx), %eax
imull 0x4(%rcx), %eax
movslq %eax, %rsi
callq 0xebb0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x14310
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d243
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0xec40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x5540
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d1ed
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rcx), %rax
imulq 0x10(%rcx), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jge 0x1df20
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1dedc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1de70
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
leaq -0x28(%rbp), %rsi
callq 0x1e7b0
leaq -0x28(%rbp), %rdi
callq 0x1df90
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)