LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::ngramVectors(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FastText::ngramVectors(std::string word) {
  std::vector<int32_t> ngrams;
  std::vector<std::string> substrings;
  Vector vec(args_->dim);
  dict_->getNgrams(word, ngrams, substrings);
  for (int32_t i = 0; i < ngrams.size(); i++) {
    vec.zero();
    if (ngrams[i] >= 0) {
      vec.addRow(*input_, ngrams[i]);
    }
    std::cout << substrings[i] << " " << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0xd03c
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rsi
callq 0x60ae
xorl %r13d, %r13d
leaq 0x38(%rsp), %r14
movq 0x15b67(%rip), %r15     # 0x27fc0
leaq 0x8709(%rip), %r12      # 0x1ab69
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
jbe 0x124cc
movq %r14, %rdi
callq 0xd078
movq (%rsp), %rax
movslq (%rax,%rbp,4), %rdx
testq %rdx, %rdx
js 0x12495
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xd19e
movq 0x20(%rsp), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x42f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4330
movq %rax, %rdi
movq %r14, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
incq %rbp
addq $0x20, %r13
jmp 0x12462
leaq 0x38(%rsp), %rdi
callq 0xd066
leaq 0x20(%rsp), %rdi
callq 0x880e
movq %rsp, %rdi
callq 0x8c0e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x124fe
movq %rax, %rbx
jmp 0x1250b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xd066
leaq 0x20(%rsp), %rdi
callq 0x880e
movq %rsp, %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVectors()
void FastText::textVectors() {
  std::vector<int32_t> line, labels;
  Vector vec(args_->dim);
  while (std::cin.peek() != EOF) {
    dict_->getLine(std::cin, line, labels, model_->rng);
    vec.zero();
    if (args_->model == model_name::bisent2vec){
      dict_->addNgrams(line, args_->wordNgrams);
    }
    for (auto it = line.cbegin(); it != line.cend(); ++it) {
      vec.addRow(*input_, *it);
    }
    if (!line.empty()) {
      vec.mul(1.0 / line.size());
    }
    std::cout << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x40(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x30(%rsp)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0xd03c
movq 0x15a6e(%rip), %r14     # 0x27fd8
movq %rsp, %r15
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x4130
cmpl $-0x1, %eax
je 0x1265c
movq 0x10(%rbx), %rdi
movq 0x60(%rbx), %r8
movl $0x110, %eax            # imm = 0x110
addq %rax, %r8
movq %r14, %rsi
movq %r15, %rdx
leaq 0x30(%rsp), %rcx
callq 0x7650
movq %r13, %rdi
callq 0xd078
movq (%rbx), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x125c9
movq 0x10(%rbx), %rdi
movl 0xb4(%rax), %edx
movq %r15, %rsi
callq 0x7364
movq (%rsp), %r12
movq %r12, %rbp
negq %rbp
cmpq 0x8(%rsp), %r12
je 0x125f4
movq 0x20(%rbx), %rsi
movslq (%r12), %rdx
movq %r13, %rdi
callq 0xd19e
addq $0x4, %r12
addq $-0x4, %rbp
jmp 0x125d3
movq (%rsp), %rax
cmpq %rax, %r12
je 0x12640
addq %rbp, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x82fc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8304(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x82b8(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r13, %rdi
callq 0xd0cc
movq 0x15979(%rip), %rdi     # 0x27fc0
movq %r13, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
jmp 0x12572
leaq 0x20(%rsp), %rdi
callq 0xd066
leaq 0x30(%rsp), %rdi
callq 0x8c0e
movq %rsp, %rdi
callq 0x8c0e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1269b
jmp 0x1268e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd066
leaq 0x30(%rsp), %rdi
callq 0x8c0e
movq %rsp, %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVectorThread(int, std::shared_ptr<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::shared_ptr<fasttext::Matrix>, int)
void FastText::textVectorThread(int thread_id, std::shared_ptr<std::vector<std::string>> sentences, std::shared_ptr<Matrix> emb, int num_threads) {
  std::vector<int32_t> line, labels;
  for (int sent_idx=thread_id; sent_idx < sentences->size(); sent_idx+=num_threads) {
    Vector vec(args_->dim);
    textVector(sentences->operator[](sent_idx), vec, line, labels);
    emb->addRow(vec, sent_idx, 1.);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r14
movq %rdi, %r15
leaq 0x40(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movslq %esi, %rbp
movslq %r8d, %rax
movq %rbp, %rbx
shlq $0x5, %rbx
movq %rax, 0x10(%rsp)
shlq $0x5, %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %r12
leaq 0x68(%rsp), %r13
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %rbp, %rcx
jbe 0x1279c
movq (%r15), %rax
movslq 0x94(%rax), %rsi
movq %r12, %rdi
callq 0xd03c
movq (%r14), %rax
movq (%rax), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x4460
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x12800
movq %r13, %rdi
callq 0x46c8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq %r12, %rsi
movq %rbp, %rdx
movss 0x89f0(%rip), %xmm0     # 0x1b170
callq 0xc01c
movq %r12, %rdi
callq 0xd066
addq 0x10(%rsp), %rbp
addq 0x8(%rsp), %rbx
jmp 0x12714
leaq 0x20(%rsp), %rdi
callq 0x8c0e
leaq 0x40(%rsp), %rdi
callq 0x8c0e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x127e3
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x46c8
jmp 0x127d9
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xd066
leaq 0x20(%rsp), %rdi
callq 0x8c0e
leaq 0x40(%rsp), %rdi
callq 0x8c0e
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::textVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, fasttext::Vector&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void FastText::textVector(std::string text, Vector& vec, std::vector<int32_t>& line, std::vector<int32_t>& labels) {
  std::istringstream text_stream(text);
  dict_->getLine(text_stream, line, labels, model_->rng);
  vec.zero();
  if (args_->model == model_name::bisent2vec){
    dict_->addNgrams(line, args_->wordNgrams);
  }
  for (auto it = line.cbegin(); it != line.cend(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (!line.empty()) {
    vec.mul(1.0 / line.size());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rsp, %r13
pushq $0x8
popq %rdx
movq %r13, %rdi
callq 0x4570
movq 0x10(%r15), %rdi
movl $0x110, %r8d            # imm = 0x110
addq 0x60(%r15), %r8
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x7650
movq %rbx, %rdi
callq 0xd078
movq (%r15), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x1286c
movq 0x10(%r15), %rdi
movl 0xb4(%rax), %edx
movq %r14, %rsi
callq 0x7364
movq (%r14), %r13
movq %r13, %r12
negq %r12
cmpq 0x8(%r14), %r13
je 0x12895
movq 0x20(%r15), %rsi
movslq (%r13), %rdx
movq %rbx, %rdi
callq 0xd19e
addq $0x4, %r13
addq $-0x4, %r12
jmp 0x12875
movq (%r14), %rax
cmpq %rax, %r13
je 0x128e0
addq %r12, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x805c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8064(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8018(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0xd0cc
movq %rsp, %rdi
callq 0x4180
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x128fb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::getVector(fasttext::Vector&, int) const
void FastText::getVector(Vector& vec, int32_t wordIdx) const {

  const std::vector<int32_t>& ngrams = dict_->getNgrams(wordIdx);
  vec.zero();
  for (auto it = ngrams.begin(); it != ngrams.end(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (ngrams.size() > 0) {
    vec.mul(1.0 / ngrams.size());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x5e42
movq %rax, %r15
movq %rbx, %rdi
callq 0xd078
movq (%r15), %r13
movq %r13, %r12
negq %r12
cmpq 0x8(%r15), %r13
je 0x12be0
movq 0x20(%r14), %rsi
movslq (%r13), %rdx
movq %rbx, %rdi
callq 0xd19e
addq $0x4, %r13
addq $-0x4, %r12
jmp 0x12bc0
movq (%r15), %rax
cmpq %rax, %r13
je 0x12c34
addq %r12, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x7d11(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7d19(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x7ccd(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd0cc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::printVocabularyVectors(bool)
void FastText::printVocabularyVectors(bool input_matrix) {
  std::vector<std::string> words = getVocab();
  std::shared_ptr<Matrix> matrix = input_matrix ? input_ : output_;
  Vector vec(args_->dim);
  std::string word;
  for(int i = 0; i < words.size(); i++) {
    word = words[i];
    const std::vector<int32_t> &ngrams = dict_->getNgrams(word);
    vec.zero();
    for (auto it = ngrams.begin(); it != ngrams.end(); ++it) {
      vec.addRow(*matrix, *it);
    }
    if (ngrams.size() > 0) {
      vec.mul(1.0 / ngrams.size());
    }
    std::cout << word << " " << " " << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xf962
xorb $0x1, %bpl
movzbl %bpl, %eax
shll $0x4, %eax
leaq (%rbx,%rax), %rsi
addq $0x20, %rsi
leaq 0x18(%rsp), %rdi
callq 0x15e92
movq %rbx, (%rsp)
movq (%rbx), %rax
movslq 0x94(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd03c
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r13d, %r13d
leaq 0x58(%rsp), %r14
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r12
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x12dd2
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r14, %rdi
callq 0x41d0
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rbp
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5e96
movq %r12, %rdi
callq 0xd078
movq 0x28(%rsp), %rbx
movq %rbx, %r15
negq %r15
cmpq 0x30(%rsp), %rbx
je 0x12d32
movq 0x18(%rsp), %rsi
movslq (%rbx), %rdx
movq %r12, %rdi
callq 0xd19e
addq $0x4, %rbx
addq $-0x4, %r15
jmp 0x12d11
movq 0x28(%rsp), %rax
cmpq %rax, %rbx
je 0x12d7f
addq %r15, %rax
negq %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x7bbd(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7bc5(%rip), %xmm0     # 0x1a920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x7b79(%rip), %xmm0     # 0x1a8e8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r12, %rdi
callq 0xd0cc
movq 0x1523a(%rip), %rdi     # 0x27fc0
movq %r14, %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x7dd1(%rip), %rsi      # 0x1ab69
callq 0x4330
movq %rax, %rdi
leaq 0x7dc2(%rip), %rsi      # 0x1ab69
callq 0x4330
movq %rax, %rdi
movq %r12, %rsi
callq 0xd46d
movq %rax, %rdi
callq 0x4190
movq %rbp, %rbx
movq %rbp, %rdi
callq 0x8c0e
incq %r13
jmp 0x12cbc
leaq 0x58(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x20(%rsp), %rdi
callq 0x8b66
leaq 0x40(%rsp), %rdi
callq 0x880e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x12e38
jmp 0x12e10
movq %rax, %rbx
jmp 0x12e24
jmp 0x12e17
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8c0e
leaq 0x58(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
callq 0xd066
leaq 0x20(%rsp), %rdi
callq 0x8b66
leaq 0x40(%rsp), %rdi
callq 0x880e
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::precomputeWordVectors(fasttext::Matrix&)
void FastText::precomputeWordVectors(Matrix& wordVectors) {
  Vector vec(args_->dim);
  wordVectors.zero();
  std::cerr << "Pre-computing word vectors...";
  for (int32_t i = 0; i < dict_->nwords(); i++) {
    std::string word = dict_->getWord(i);
    getVector(vec, word);
    real norm = vec.norm();
    wordVectors.addRow(vec, i, 1.0 / norm);
  }
  std::cerr << " done." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
movq %rsp, %rdi
callq 0xd03c
movq %rbx, %rdi
callq 0xbee0
movq 0x15152(%rip), %rdi     # 0x27ff0
leaq 0x89c5(%rip), %rsi      # 0x1b86a
callq 0x4330
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movq 0x10(%r14), %rdi
callq 0x5e34
cltq
cmpq %rax, %r15
jge 0x12f14
movq 0x10(%r14), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x63b2
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xf988
movq %r13, %rdi
callq 0xd090
movss 0x827e(%rip), %xmm1     # 0x1b170
divss %xmm0, %xmm1
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movaps %xmm1, %xmm0
callq 0xc01c
movq %r12, %rdi
callq 0x46c8
incq %r15
jmp 0x12eb5
movq 0x150d5(%rip), %rdi     # 0x27ff0
leaq 0x8966(%rip), %rsi      # 0x1b888
callq 0x4330
movq %rax, %rdi
callq 0x4190
movq %rsp, %rdi
callq 0xd066
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x12f4b
jmp 0x12f4b
jmp 0x12f50
movq %rax, %rbx
jmp 0x12f5d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x46c8
movq %rsp, %rdi
callq 0xd066
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::nn(int)
void FastText::nn(int32_t k) {
  std::string queryWord;
  Vector queryVec(args_->dim);
  Matrix wordVectors(dict_->nwords(), args_->dim);
  precomputeWordVectors(wordVectors);
  std::set<std::string> banSet;
  std::cerr << "Query word? " << std::endl;
  while (std::cin >> queryWord) {
    banSet.clear();
    banSet.insert(queryWord);
    getVector(queryVec, queryWord);
    findNN(wordVectors, queryVec, k, banSet);
    std::cerr << "Query word? " << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
movq %rsp, %rdi
callq 0xd03c
movq 0x10(%r14), %rdi
callq 0x5e34
movslq %eax, %rsi
movq (%r14), %rax
movslq 0x94(%rax), %rdx
leaq 0x10(%rsp), %rdi
callq 0xbdec
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x12e6a
leaq 0x50(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x149ce(%rip), %rdi     # 0x27ff0
leaq 0x8288(%rip), %rsi      # 0x1b8b1
callq 0x4330
movq %rax, %rdi
callq 0x4190
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
movq %rsp, %rbp
leaq 0x8267(%rip), %r15      # 0x1b8b1
movq 0x14987(%rip), %rdi     # 0x27fd8
movq %r12, %rsi
callq 0x4400
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x136b6
movq %r13, %rdi
callq 0x17964
movq %r13, %rdi
movq %r12, %rsi
callq 0x17992
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xf988
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
movl %ebx, %ecx
movq %r13, %r8
callq 0x1315c
movq 0x1494c(%rip), %rdi     # 0x27ff0
movq %r15, %rsi
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x1364a
leaq 0x48(%rsp), %rdi
callq 0x15ea6
leaq 0x10(%rsp), %rdi
callq 0xbed2
movq %rsp, %rdi
callq 0xd066
leaq 0x28(%rsp), %rdi
callq 0x46c8
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13709
movq %rax, %rbx
jmp 0x1371b
jmp 0x136fc
movq %rax, %rbx
jmp 0x13713
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x15ea6
leaq 0x10(%rsp), %rdi
callq 0xbed2
movq %rsp, %rdi
callq 0xd066
leaq 0x28(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::analogies(int)
void FastText::analogies(int32_t k) {
  std::string word;
  Vector buffer(args_->dim), query(args_->dim);
  Matrix wordVectors(dict_->nwords(), args_->dim);
  precomputeWordVectors(wordVectors);
  std::set<std::string> banSet;
  std::cerr << "Query triplet (A - B + C)? " << std::endl;
  while (true) {
    banSet.clear();
    query.zero();
    std::cin >> word;
    banSet.insert(word);
    getVector(buffer, word);
    query.addVector(buffer, 1.0);
    std::cin >> word;
    banSet.insert(word);
    getVector(buffer, word);
    query.addVector(buffer, -1.0);
    std::cin >> word;
    banSet.insert(word);
    getVector(buffer, word);
    query.addVector(buffer, 1.0);

    findNN(wordVectors, query, k, banSet);
    std::cerr << "Query triplet (A - B + C)? " << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, 0xc(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
movq (%rdi), %rax
movslq 0x94(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0xd03c
movq (%r14), %rax
movslq 0x94(%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0xd03c
movq 0x10(%r14), %rdi
callq 0x5e34
movslq %eax, %rsi
movq (%r14), %rax
movslq 0x94(%rax), %rdx
leaq 0x30(%rsp), %rdi
callq 0xbdec
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x12e6a
leaq 0x70(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x14823(%rip), %rdi     # 0x27ff0
leaq 0x80ea(%rip), %rsi      # 0x1b8be
callq 0x4330
movq %rax, %rdi
callq 0x4190
leaq 0x68(%rsp), %r15
leaq 0x10(%rsp), %r12
movq 0x147e6(%rip), %r13     # 0x27fd8
leaq 0x48(%rsp), %rbp
leaq 0x20(%rsp), %rbx
movq %r15, %rdi
callq 0x17964
movq %r12, %rdi
callq 0xd078
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4400
movq %r15, %rdi
movq %rbp, %rsi
callq 0x17992
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf988
movq %r12, %rdi
movq %rbx, %rsi
movss 0x7932(%rip), %xmm0     # 0x1b170
callq 0xd148
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4400
movq %r15, %rdi
movq %rbp, %rsi
callq 0x17992
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf988
movq %r12, %rdi
movq %rbx, %rsi
movss 0x7ea3(%rip), %xmm0     # 0x1b718
callq 0xd148
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4400
movq %r15, %rdi
movq %rbp, %rsi
callq 0x17992
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf988
movq %r12, %rdi
movq %rbx, %rsi
movss 0x78c4(%rip), %xmm0     # 0x1b170
callq 0xd148
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
movl 0xc(%rsp), %ecx
movq %r15, %r8
callq 0x1315c
movq 0x14721(%rip), %rdi     # 0x27ff0
leaq 0x7fe8(%rip), %rsi      # 0x1b8be
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x137fc
jmp 0x138ea
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x15ea6
jmp 0x138fc
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbed2
jmp 0x1390b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd066
jmp 0x1391a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd066
jmp 0x13929
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/fasttext.cc
// Function: fasttext::FastText::trainDict(std::shared_ptr<fasttext::Args>)
void FastText::trainDict(std::shared_ptr<Args> args) {
  args_ = args;
  dict_ = std::make_shared<Dictionary>(args_);
  if (args_->input == "-") {
    // manage expectations
    std::cerr << "Cannot use stdin for training!" << std::endl;
    exit(EXIT_FAILURE);
  }
  std::ifstream ifs(args_->input);
  if (!ifs.is_open()) {
    std::cerr << "Input file cannot be opened!" << std::endl;
    exit(EXIT_FAILURE);
  }
  dict_->readFromFile(ifs);
  saveDict();
  ifs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
callq 0xeb9a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15ba7
leaq 0x10(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x162fc
leaq 0x10(%rsp), %rdi
callq 0x8b66
movq (%rbx), %rdi
leaq 0x690f(%rip), %rsi      # 0x1b9c0
callq 0x5b9f
testb %al, %al
jne 0x15111
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x4520
leaq 0x80(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x15134
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x66a2
movq %rbx, %rdi
callq 0x100f8
leaq 0x8(%rsp), %rdi
callq 0x40a0
leaq 0x8(%rsp), %rdi
callq 0x40e0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq 0x12ed8(%rip), %rdi     # 0x27ff0
leaq 0x68a3(%rip), %rsi      # 0x1b9c2
callq 0x4330
movq %rax, %rdi
callq 0x4190
pushq $0x1
popq %rdi
callq 0x43b0
movq 0x12eb5(%rip), %rdi     # 0x27ff0
leaq 0x689f(%rip), %rsi      # 0x1b9e1
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x1512c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printUsage()
void printUsage() {
  std::cerr
    << "usage: fasttext <command> <args>\n\n"
    << "The commands supported by fasttext are:\n\n"
    << "  bisent2vec                  train unsupervised sentence embeddings\n"
    << "  quantize                  quantize a model to reduce the memory usage\n"
    << "  test                      evaluate a supervised classifier\n"
    << "  predict                   predict most likely labels\n"
    << "  predict-prob              predict most likely labels with probabilities\n"
    << "  transgram                  train a skipgram model\n"
    << "  print-word-vectors        print word vectors given a trained model\n"
    << "  print-sentence-vectors    print sentence vectors given a trained model\n"
    << "  print-vocabulary-vectors  print unigram vectors in vocabulary\n"
    << "  print-vocabulary          print word in vocabulary with count\n"
    << "  nn                        query for nearest neighbors\n"
    << "  nnSent                    query for nearest neighbors for sentences\n"
    << "  analogies                 query for analogies\n"
    << "  analogiesSent             query for analogies for Sentences\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x102c4(%rip), %rdi     # 0x27ff0
leaq 0x41e3(%rip), %rsi      # 0x1bf16
callq 0x4330
leaq 0x41fa(%rip), %rsi      # 0x1bf39
movq %rax, %rdi
callq 0x4330
leaq 0x4215(%rip), %rsi      # 0x1bf63
movq %rax, %rdi
callq 0x4330
leaq 0x424c(%rip), %rsi      # 0x1bfa9
movq %rax, %rdi
callq 0x4330
leaq 0x4286(%rip), %rsi      # 0x1bff2
movq %rax, %rdi
callq 0x4330
leaq 0x42b5(%rip), %rsi      # 0x1c030
movq %rax, %rdi
callq 0x4330
leaq 0x42de(%rip), %rsi      # 0x1c068
movq %rax, %rdi
callq 0x4330
leaq 0x431a(%rip), %rsi      # 0x1c0b3
movq %rax, %rdi
callq 0x4330
leaq 0x4340(%rip), %rsi      # 0x1c0e8
movq %rax, %rdi
callq 0x4330
leaq 0x4377(%rip), %rsi      # 0x1c12e
movq %rax, %rdi
callq 0x4330
leaq 0x43b2(%rip), %rsi      # 0x1c178
movq %rax, %rdi
callq 0x4330
leaq 0x43e4(%rip), %rsi      # 0x1c1b9
movq %rax, %rdi
callq 0x4330
leaq 0x4416(%rip), %rsi      # 0x1c1fa
movq %rax, %rdi
callq 0x4330
leaq 0x4440(%rip), %rsi      # 0x1c233
movq %rax, %rdi
callq 0x4330
leaq 0x4478(%rip), %rsi      # 0x1c27a
movq %rax, %rdi
callq 0x4330
leaq 0x449a(%rip), %rsi      # 0x1c2ab
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printTestUsage()
void printTestUsage() {
  std::cerr
    << "usage: fasttext test <model> <test-data> [<k>]\n\n"
    << "  <model>      model filename\n"
    << "  <test-data>  test data filename (if -, read from stdin)\n"
    << "  <k>          (optional; 1 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x101a9(%rip), %rdi     # 0x27ff0
leaq 0x44bc(%rip), %rsi      # 0x1c30a
callq 0x4330
leaq 0x44e1(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x44f1(%rip), %rsi      # 0x1c35a
movq %rax, %rdi
callq 0x4330
leaq 0x451d(%rip), %rsi      # 0x1c395
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPredictUsage()
void printPredictUsage() {
  std::cerr
    << "usage: fasttext predict[-prob] <model> <test-data> [<k>]\n\n"
    << "  <model>      model filename\n"
    << "  <test-data>  test data filename (if -, read from stdin)\n"
    << "  <k>          (optional; 1 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x1015f(%rip), %rdi     # 0x27ff0
leaq 0x453b(%rip), %rsi      # 0x1c3d3
callq 0x4330
leaq 0x4497(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x44a7(%rip), %rsi      # 0x1c35a
movq %rax, %rdi
callq 0x4330
leaq 0x44d3(%rip), %rsi      # 0x1c395
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPrintWordVectorsUsage()
void printPrintWordVectorsUsage() {
  std::cerr
    << "usage: fasttext print-word-vectors <model>\n\n"
    << "  <model>      model filename\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x10115(%rip), %rdi     # 0x27ff0
leaq 0x452c(%rip), %rsi      # 0x1c40e
callq 0x4330
leaq 0x444d(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPrintSentenceVectorsUsage()
void printPrintSentenceVectorsUsage() {
  std::cerr
    << "usage: fasttext print-sentence-vectors <model>\n\n"
    << "  <model>      model filename\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x100e9(%rip), %rdi     # 0x27ff0
leaq 0x452d(%rip), %rsi      # 0x1c43b
callq 0x4330
leaq 0x4421(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPrintVocabularyVectorsUsage()
void printPrintVocabularyVectorsUsage() {
  std::cerr
    << "usage: fasttext print-vocabulary-vectors <model>\n\n"
    << "  <model>      model filename\n"
    << "  <matrix>     embedding matrix: input|output\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x100bd(%rip), %rdi     # 0x27ff0
leaq 0x4532(%rip), %rsi      # 0x1c46c
callq 0x4330
leaq 0x43f5(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x454a(%rip), %rsi      # 0x1c49f
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPrintVocabularyUsage()
void printPrintVocabularyUsage() {
  std::cerr
    << "usage: fasttext print-vocabulary <model>\n\n"
    << "  <model>      model filename\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x10082(%rip), %rdi     # 0x27ff0
leaq 0x4559(%rip), %rsi      # 0x1c4ce
callq 0x4330
leaq 0x43ba(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printPrintNgramsUsage()
void printPrintNgramsUsage() {
  std::cerr
    << "usage: fasttext print-ngrams <model> <word>\n\n"
    << "  <model>      model filename\n"
    << "  <word>       word to print\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0x10056(%rip), %rdi     # 0x27ff0
leaq 0x4558(%rip), %rsi      # 0x1c4f9
callq 0x4330
leaq 0x438e(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x456b(%rip), %rsi      # 0x1c527
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: quantize(int, char**)
void quantize(int argc, char** argv) {
  std::shared_ptr<Args> a = std::make_shared<Args>();
  if (argc < 3) {
    printQuantizeUsage();
    a->printHelp();
    exit(EXIT_FAILURE);
  }
  a->parseArgs(argc, argv);
  FastText fasttext;
  fasttext.quantize(a);
  exit(0);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
callq 0x15b8c
cmpl $0x2, %ebp
jg 0x17ffe
callq 0x17e22
movq (%rsp), %rdi
callq 0x5428
pushq $0x1
popq %rdi
callq 0x43b0
movq (%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4b20
leaq 0x20(%rsp), %rdi
callq 0xf93c
leaq 0x10(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8b26
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x10f68
leaq 0x10(%rsp), %rdi
callq 0x1905c
xorl %edi, %edi
callq 0x43b0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8b66
leaq 0x20(%rsp), %rdi
callq 0x19066
jmp 0x18062
jmp 0x1805f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8b66
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printNNUsage()
void printNNUsage() {
  std::cout
    << "usage: fasttext nn <model> <k>\n\n"
    << "  <model>      model filename\n"
    << "  <k>          (optional; 10 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0xff44(%rip), %rdi      # 0x27fc0
leaq 0x44c2(%rip), %rsi      # 0x1c545
callq 0x4330
leaq 0x42ac(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x44c8(%rip), %rsi      # 0x1c566
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printNNSentUsage()
void printNNSentUsage() {
  std::cerr
    << "usage: fasttext nnSent <model> <corpus> <k>\n\n"
    << "  <model>      model filename\n"
    << "  <corpus>     corpus filename \n"
    << "  <k>          (optional; 10 by default) predict top k labels\n"
    << std::endl;
    std::cout<<"NOTE : A corpus file is required to find similar sentences."<<std::endl;
}

// Assembly:
pushq %rax
movq 0xff39(%rip), %rdi      # 0x27ff0
leaq 0x44e7(%rip), %rsi      # 0x1c5a5
callq 0x4330
leaq 0x4271(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x44fa(%rip), %rsi      # 0x1c5d3
movq %rax, %rdi
callq 0x4330
leaq 0x447e(%rip), %rsi      # 0x1c566
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x4190
movq 0xfec1(%rip), %rdi      # 0x27fc0
leaq 0x44ee(%rip), %rsi      # 0x1c5f4
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printAnalogiesUsage()
void printAnalogiesUsage() {
  std::cout
    << "usage: fasttext analogies <model> <k>\n\n"
    << "  <model>      model filename\n"
    << "  <k>          (optional; 10 by default) predict top k labels\n"
    << std::endl;
}

// Assembly:
pushq %rax
movq 0xfea4(%rip), %rdi      # 0x27fc0
leaq 0x450d(%rip), %rsi      # 0x1c630
callq 0x4330
leaq 0x420c(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x4428(%rip), %rsi      # 0x1c566
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
popq %rax
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printAnalogiesSentUsage()
void printAnalogiesSentUsage() {
  std::cout
    << "usage: fasttext analogiesSent <model> <corpus> <k>\n\n"
    << "  <model>      model filename\n"
    << "  <corpus>     corpus filename \n"
    << "  <k>          (optional; 10 by default) predict top k labels\n"
    << std::endl;
  std::cout<<"NOTE : A corpus file is required to find similar sentences."<<std::endl;
}

// Assembly:
pushq %rbx
movq 0xfe69(%rip), %rbx      # 0x27fc0
leaq 0x44fa(%rip), %rsi      # 0x1c658
movq %rbx, %rdi
callq 0x4330
leaq 0x41ce(%rip), %rsi      # 0x1c33b
movq %rax, %rdi
callq 0x4330
leaq 0x4457(%rip), %rsi      # 0x1c5d3
movq %rax, %rdi
callq 0x4330
leaq 0x43db(%rip), %rsi      # 0x1c566
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x4190
leaq 0x4452(%rip), %rsi      # 0x1c5f4
movq %rbx, %rdi
callq 0x4330
movq %rax, %rdi
popq %rbx
jmp 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: test(int, char**)
void test(int argc, char** argv) {
  if (argc < 4 || argc > 5) {
    printTestUsage();
    exit(EXIT_FAILURE);
  }
  int32_t k = 1;
  if (argc >= 5) {
    k = atoi(argv[4]);
  }

  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));

  std::string infile(argv[3]);
  if (infile == "-") {
    fasttext.test(std::cin, k);
  } else {
    std::ifstream ifs(infile);
    if (!ifs.is_open()) {
      std::cerr << "Test file cannot be opened!" << std::endl;
      exit(EXIT_FAILURE);
    }
    fasttext.test(ifs, k);
    ifs.close();
  }
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
leal -0x6(%rdi), %eax
cmpl $-0x3, %eax
ja 0x181d2
callq 0x17e3f
pushq $0x1
popq %rdi
callq 0x43b0
movq %rsi, %r14
cmpl $0x5, %edi
jb 0x181e7
movq 0x20(%r14), %rdi
callq 0x44e0
movl %eax, %ebx
jmp 0x181ea
pushq $0x1
popq %rbx
leaq 0x28(%rsp), %rdi
callq 0xf93c
movq 0x10(%r14), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5b64
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0xb0(%rsp), %rdi
callq 0x46c8
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x5b64
leaq 0x3775(%rip), %rsi      # 0x1b9c0
leaq 0x8(%rsp), %rdi
callq 0x5b9f
testb %al, %al
je 0x18273
movq 0xfd78(%rip), %rsi      # 0x27fd8
leaq 0x28(%rsp), %rdi
movl %ebx, %edx
callq 0x11bde
xorl %edi, %edi
callq 0x43b0
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4520
leaq 0x128(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x182c9
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl %ebx, %edx
callq 0x11bde
leaq 0xb0(%rsp), %rdi
callq 0x40a0
leaq 0xb0(%rsp), %rdi
callq 0x40e0
jmp 0x1826c
movq 0xfd20(%rip), %rdi      # 0x27ff0
leaq 0x43b6(%rip), %rsi      # 0x1c68d
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x181ca
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x40e0
jmp 0x18300
jmp 0x182fd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x18314
jmp 0x1831b
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x46c8
jmp 0x1831e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: predict(int, char**)
void predict(int argc, char** argv) {
  if (argc < 4 || argc > 5) {
    printPredictUsage();
    exit(EXIT_FAILURE);
  }
  int32_t k = 1;
  if (argc >= 5) {
    k = atoi(argv[4]);
  }

  bool print_prob = std::string(argv[1]) == "predict-prob";
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));

  std::string infile(argv[3]);
  if (infile == "-") {
    fasttext.predict(std::cin, k, print_prob);
  } else {
    std::ifstream ifs(infile);
    if (!ifs.is_open()) {
      std::cerr << "Input file cannot be opened!" << std::endl;
      exit(EXIT_FAILURE);
    }
    fasttext.predict(ifs, k, print_prob);
    ifs.close();
  }

  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
leal -0x6(%rdi), %eax
cmpl $-0x3, %eax
ja 0x18352
callq 0x17e89
pushq $0x1
popq %rdi
callq 0x43b0
movq %rsi, %r14
cmpl $0x5, %edi
jb 0x18367
movq 0x20(%r14), %rdi
callq 0x44e0
movl %eax, %ebx
jmp 0x1836a
pushq $0x1
popq %rbx
movq 0x8(%r14), %rsi
leaq 0xb0(%rsp), %r15
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
callq 0x5b64
leaq 0x431f(%rip), %rsi      # 0x1c6a9
movq %r15, %rdi
callq 0x5b9f
movl %eax, %ebp
movq %r15, %rdi
callq 0x46c8
leaq 0x28(%rsp), %rdi
callq 0xf93c
movq 0x10(%r14), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5b64
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0xb0(%rsp), %rdi
callq 0x46c8
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x5b64
leaq 0x35c3(%rip), %rsi      # 0x1b9c0
leaq 0x8(%rsp), %rdi
callq 0x5b9f
testb %al, %al
je 0x18429
movzbl %bpl, %ecx
movq 0xfbc2(%rip), %rsi      # 0x27fd8
leaq 0x28(%rsp), %rdi
movl %ebx, %edx
callq 0x1201a
xorl %edi, %edi
callq 0x43b0
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4520
leaq 0x128(%rsp), %rdi
callq 0x40c0
testb %al, %al
je 0x18483
movzbl %bpl, %ecx
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl %ebx, %edx
callq 0x1201a
leaq 0xb0(%rsp), %rdi
callq 0x40a0
leaq 0xb0(%rsp), %rdi
callq 0x40e0
jmp 0x18422
movq 0xfb66(%rip), %rdi      # 0x27ff0
leaq 0x3550(%rip), %rsi      # 0x1b9e1
callq 0x4330
movq %rax, %rdi
callq 0x4190
jmp 0x1834a
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x40e0
jmp 0x184ba
jmp 0x184b7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x184ce
jmp 0x184d5
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x46c8
jmp 0x184d8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printWordVectors(int, char**)
void printWordVectors(int argc, char** argv) {
  if (argc != 3) {
    printPrintWordVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printWordVectors();
  exit(0);
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
cmpl $0x3, %edi
jne 0x18546
movq %rsi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf93c
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5b64
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x28(%rsp), %rdi
callq 0x12c3e
xorl %edi, %edi
callq 0x43b0
callq 0x17ed3
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x18564
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x18567
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printSentenceVectors(int, char**)
void printSentenceVectors(int argc, char** argv) {
  if (argc != 3) {
    printPrintSentenceVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printSentenceVectors();
  exit(0);
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
cmpl $0x3, %edi
jne 0x185d5
movq %rsi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf93c
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5b64
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x28(%rsp), %rdi
callq 0x12e54
xorl %edi, %edi
callq 0x43b0
callq 0x17eff
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x185f3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x185f6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printVocabularyVectors(int, char**)
void printVocabularyVectors(int argc, char** argv) {
  if (argc != 4) {
    printPrintVocabularyVectorsUsage();
    exit(EXIT_FAILURE);
  }
  std::string matrix_type = std::string(argv[3]);
  if (matrix_type != "input" && matrix_type != "output") {
    printPrintVocabularyVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printVocabularyVectors(matrix_type == "input");
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
cmpl $0x4, %edi
jne 0x1865f
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
leaq 0x30(%rsp), %r14
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x5b64
leaq 0x1a71(%rip), %rsi      # 0x1a0a8
movq %r14, %rdi
callq 0x190ad
testb %al, %al
je 0x1866c
leaq 0x1a6b(%rip), %rsi      # 0x1a0b5
leaq 0x30(%rsp), %rdi
callq 0x190ad
testb %al, %al
je 0x1866c
callq 0x17f2b
jmp 0x18664
callq 0x17f2b
pushq $0x1
popq %rdi
callq 0x43b0
leaq 0x50(%rsp), %rdi
callq 0xf93c
movq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5b64
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x10(%rsp), %rdi
callq 0x46c8
leaq 0x19fa(%rip), %rsi      # 0x1a0a8
leaq 0x30(%rsp), %rdi
callq 0x5b9f
movzbl %al, %esi
leaq 0x50(%rsp), %rdi
callq 0x12c44
xorl %edi, %edi
callq 0x43b0
jmp 0x186df
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x46c8
jmp 0x186e2
jmp 0x186ee
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x19066
jmp 0x186f1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printVocabulary(int, char**)
void printVocabulary(int argc, char** argv) {
  if (argc != 3) {
    printPrintVocabularyUsage();
    exit(EXIT_FAILURE);
  }

  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  std::vector<std::string> vocabulary = fasttext.getVocab();
  std::vector<int64_t> counts = fasttext.getUnigramsCounts();
  for (int i = 0; i < vocabulary.size(); i++) {
    std::cout << vocabulary[i] << " " << counts[i] << std::endl;
  }
  exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpl $0x3, %edi
jne 0x187d8
movq %rsi, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf93c
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5b64
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf962
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf974
xorl %r15d, %r15d
movq 0xf840(%rip), %rbx      # 0x27fc0
leaq 0x23e2(%rip), %r14      # 0x1ab69
xorl %r12d, %r12d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x187e5
addq %r15, %rsi
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x4330
movq 0x28(%rsp), %rcx
movq (%rcx,%r12,8), %rsi
movq %rax, %rdi
callq 0x4320
movq %rax, %rdi
callq 0x4190
incq %r12
addq $0x20, %r15
jmp 0x1878a
callq 0x17f66
pushq $0x1
popq %rdi
callq 0x43b0
xorl %edi, %edi
callq 0x43b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9a28
jmp 0x187fe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x880e
jmp 0x1881e
jmp 0x1881b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x1881e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: printNgrams(int, char**)
void printNgrams(int argc, char** argv) {
  if (argc != 4) {
    printPrintNgramsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.ngramVectors(std::string(argv[3]));
  exit(0);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
cmpl $0x4, %edi
jne 0x188ae
movq %rsi, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf93c
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5b64
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x8(%rsp), %rdi
callq 0x46c8
movq 0x18(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5b64
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x123f6
leaq 0x28(%rsp), %rdi
callq 0x46c8
xorl %edi, %edi
callq 0x43b0
callq 0x17f92
pushq $0x1
popq %rdi
callq 0x43b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x188cf
jmp 0x188d6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x188d9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: nn(int, char**)
void nn(int argc, char** argv) {
  int32_t k;
  if (argc == 3) {
    k = 10;
  } else if (argc == 4) {
    k = atoi(argv[3]);
  } else {
    printNNUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.nn(k);
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
cmpl $0x3, %edi
je 0x1890f
cmpl $0x4, %edi
jne 0x18960
movq 0x18(%r14), %rdi
callq 0x44e0
movl %eax, %ebx
jmp 0x18912
pushq $0xa
popq %rbx
leaq 0x30(%rsp), %rdi
callq 0xf93c
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5b64
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x10(%rsp), %rdi
callq 0x46c8
leaq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x1359e
xorl %edi, %edi
callq 0x43b0
callq 0x18074
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x1897e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x46c8
jmp 0x18981
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: nnSent(int, char**)
void nnSent(int argc, char** argv) {
  int32_t k;
  if (argc == 4) {
    k = 10;
  } else if (argc == 5) {
    k = atoi(argv[4]);
  } else {
    printNNSentUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.nnSent(k,std::string(argv[3]));
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
cmpl $0x4, %edi
je 0x189bb
cmpl $0x5, %edi
jne 0x18a2e
movq 0x20(%r14), %rdi
callq 0x44e0
movl %eax, %ebx
jmp 0x189be
pushq $0xa
popq %rbx
leaq 0x50(%rsp), %rdi
callq 0xf93c
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5b64
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x10(%rsp), %rdi
callq 0x46c8
movq 0x18(%r14), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5b64
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %ebx, %esi
callq 0x1393c
leaq 0x30(%rsp), %rdi
callq 0x46c8
xorl %edi, %edi
callq 0x43b0
callq 0x180af
pushq $0x1
popq %rdi
callq 0x43b0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x18a4f
jmp 0x18a56
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x46c8
jmp 0x18a59
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O2/epfml[P]Bi-Sent2Vec/src/main.cc
// Function: analogies(int, char**)
void analogies(int argc, char** argv) {
  int32_t k;
  if (argc == 3) {
    k = 10;
  } else if (argc == 4) {
    k = atoi(argv[3]);
  } else {
    printAnalogiesUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.analogies(k);
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
cmpl $0x3, %edi
je 0x18a8f
cmpl $0x4, %edi
jne 0x18ae0
movq 0x18(%r14), %rdi
callq 0x44e0
movl %eax, %ebx
jmp 0x18a92
pushq $0xa
popq %rbx
leaq 0x30(%rsp), %rdi
callq 0xf93c
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5b64
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $-0x1
popq %rcx
xorl %edx, %edx
callq 0x1066c
leaq 0x10(%rsp), %rdi
callq 0x46c8
leaq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x1372e
xorl %edi, %edi
callq 0x43b0
callq 0x18114
pushq $0x1
popq %rdi
callq 0x43b0
jmp 0x18afe
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x46c8
jmp 0x18b01
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19066
movq %rbx, %rdi
callq 0x45d0