LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f575(%rip), %rdi     # 0x5eff0
leaq 0x4949(%rip), %rsi      # 0x443cb
callq 0x5420
movq %rax, %rdi
leaq 0x483a(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
movq 0x1f4f0(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f535(%rip), %rdi     # 0x5eff0
leaq 0x493a(%rip), %rsi      # 0x443fc
callq 0x5420
movq %rax, %rdi
leaq 0x47fa(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x494f(%rip), %rsi      # 0x4442f
callq 0x5420
movq %rax, %rdi
movq 0x1f4a1(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f4e5(%rip), %rdi     # 0x5eff0
leaq 0x494c(%rip), %rsi      # 0x4445e
callq 0x5420
movq %rax, %rdi
leaq 0x47aa(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
movq 0x1f460(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f4a5(%rip), %rdi     # 0x5eff0
leaq 0x4937(%rip), %rsi      # 0x44489
callq 0x5420
movq %rax, %rdi
leaq 0x476a(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x4947(%rip), %rsi      # 0x444b7
callq 0x5420
movq %rax, %rdi
movq 0x1f411(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x342b0
cmpl $0x3, -0x4(%rbp)
jge 0x3fbe6
callq 0x3f940
jmp 0x3fbb8
leaq -0x20(%rbp), %rdi
callq 0xe6e0
movq %rax, %rdi
callq 0x6f50
jmp 0x3fbcb
movl $0x1, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3fc71
leaq -0x20(%rbp), %rdi
callq 0xe6e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5f50
jmp 0x3fc00
leaq -0xb8(%rbp), %rdi
callq 0x27dc0
jmp 0x3fc0e
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xe060
movq -0xd0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x2a550
jmp 0x3fc3a
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
movq -0x28(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f31d(%rip), %rdi     # 0x5efb8
leaq 0x4833(%rip), %rsi      # 0x444d5
callq 0x5420
movq %rax, %rdi
leaq 0x461a(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x4836(%rip), %rsi      # 0x444f6
callq 0x5420
movq %rax, %rdi
movq 0x1f2c1(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f305(%rip), %rdi     # 0x5eff0
leaq 0x4843(%rip), %rsi      # 0x44535
callq 0x5420
movq %rax, %rdi
leaq 0x45ca(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x4853(%rip), %rsi      # 0x44563
callq 0x5420
movq %rax, %rdi
leaq 0x47d7(%rip), %rsi      # 0x444f6
callq 0x5420
movq %rax, %rdi
movq 0x1f262(%rip), %rsi     # 0x5ef90
callq 0x5460
movq 0x1f27e(%rip), %rdi     # 0x5efb8
leaq 0x4843(%rip), %rsi      # 0x44584
callq 0x5420
movq %rax, %rdi
movq 0x1f240(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f24d(%rip), %rdi     # 0x5efb8
leaq 0x484e(%rip), %rsi      # 0x445c0
callq 0x5420
movq %rax, %rdi
leaq 0x454a(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x4766(%rip), %rsi      # 0x444f6
callq 0x5420
movq %rax, %rdi
movq 0x1f1f1(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1f1fd(%rip), %rdi     # 0x5efb8
leaq 0x4826(%rip), %rsi      # 0x445e8
callq 0x5420
movq %rax, %rdi
leaq 0x44fa(%rip), %rsi      # 0x442cb
callq 0x5420
movq %rax, %rdi
leaq 0x4783(%rip), %rsi      # 0x44563
callq 0x5420
movq %rax, %rdi
leaq 0x4707(%rip), %rsi      # 0x444f6
callq 0x5420
movq %rax, %rdi
movq 0x1f192(%rip), %rsi     # 0x5ef90
callq 0x5460
movq 0x1f1ae(%rip), %rdi     # 0x5efb8
leaq 0x4773(%rip), %rsi      # 0x44584
callq 0x5420
movq %rax, %rdi
movq 0x1f170(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
je 0x40487
callq 0x3fa30
movl $0x1, %edi
callq 0x54f0
leaq -0x98(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x57b0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7c10
jmp 0x404d1
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x404ed
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
leaq -0x98(%rbp), %rdi
callq 0x2d910
jmp 0x40513
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x4054c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
jmp 0x4056c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x41a10
movq -0xc8(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
je 0x405b7
callq 0x3fa70
movl $0x1, %edi
callq 0x54f0
leaq -0x98(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x57b0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7c10
jmp 0x40601
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x4061d
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
leaq -0x98(%rbp), %rdi
callq 0x2dc60
jmp 0x40643
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x4067c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
jmp 0x4069c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x41a10
movq -0xc8(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
je 0x406e7
callq 0x3fab0
movl $0x1, %edi
callq 0x54f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x57b0
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7c10
jmp 0x4071f
leaq -0x31(%rbp), %rdi
callq 0x5480
leaq 0x193c(%rip), %rsi      # 0x4206b
leaq -0x30(%rbp), %rdi
callq 0x41a80
movb %al, -0x109(%rbp)
jmp 0x40740
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0x4074c
jmp 0x407ac
leaq 0x1925(%rip), %rsi      # 0x42078
leaq -0x30(%rbp), %rdi
callq 0x41a80
movb %al, -0x10a(%rbp)
jmp 0x40764
movb -0x10a(%rbp), %al
testb $0x1, %al
jne 0x40770
jmp 0x407ac
callq 0x3fab0
jmp 0x40777
movl $0x1, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x5480
jmp 0x408ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x408b1
leaq -0xd0(%rbp), %rdi
callq 0x27dc0
jmp 0x407ba
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x120(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x57b0
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x7c10
jmp 0x407f8
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x40814
leaq -0xf0(%rbp), %rdi
callq 0x58d8
leaq -0xf1(%rbp), %rdi
callq 0x5480
leaq 0x1838(%rip), %rsi      # 0x4206b
leaq -0x30(%rbp), %rdi
callq 0x7cc0
movb %al, -0x121(%rbp)
jmp 0x40844
movb -0x121(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0xd0(%rbp), %rdi
callq 0x2d930
jmp 0x4085e
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4088b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x58d8
leaq -0xf1(%rbp), %rdi
callq 0x5480
jmp 0x408a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x41a10
leaq -0x30(%rbp), %rdi
callq 0x58d8
movq -0x40(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
je 0x408f7
callq 0x3fb00
movl $0x1, %edi
callq 0x54f0
leaq -0x98(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x57b0
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7c10
jmp 0x40941
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x4095d
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
leaq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x27e40
jmp 0x4098a
leaq -0x100(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x27e80
jmp 0x4099f
movl $0x0, -0x104(%rbp)
movslq -0x104(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x122c0
movq %rax, %rcx
movq -0x120(%rbp), %rax
cmpq %rcx, %rax
jae 0x40afb
movslq -0x104(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x35170
movq %rax, %rsi
movq 0x1e5c5(%rip), %rdi     # 0x5efb8
callq 0x53e0
movq %rax, -0x128(%rbp)
jmp 0x40a01
movq -0x128(%rbp), %rdi
leaq 0x2132(%rip), %rsi      # 0x42b41
callq 0x5420
movq %rax, -0x130(%rbp)
jmp 0x40a1d
movslq -0x104(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x41ab0
movq -0x130(%rbp), %rdi
movq (%rax), %rsi
callq 0x5810
movq %rax, -0x138(%rbp)
jmp 0x40a48
movq -0x138(%rbp), %rdi
movq 0x1e53a(%rip), %rsi     # 0x5ef90
callq 0x5460
jmp 0x40a5d
jmp 0x40a5f
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x409a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x40aa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
jmp 0x40b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x40b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x40b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xecf0
jmp 0x40b02
xorl %edi, %edi
callq 0x54f0
leaq -0xe8(%rbp), %rdi
callq 0xe820
leaq -0x98(%rbp), %rdi
callq 0x41a10
movq -0xc8(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
je 0x40b57
callq 0x3fb40
movl $0x1, %edi
callq 0x54f0
leaq -0x98(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x57b0
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x7c10
jmp 0x40ba1
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x40bbd
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x57b0
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x7c10
jmp 0x40c13
leaq -0x98(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2cbc0
jmp 0x40c28
leaq -0xf0(%rbp), %rdi
callq 0x58d8
leaq -0xf1(%rbp), %rdi
callq 0x5480
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x40c79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x58d8
leaq -0xb9(%rbp), %rdi
callq 0x5480
jmp 0x40cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x40cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x58d8
leaq -0xf1(%rbp), %rdi
callq 0x5480
leaq -0x98(%rbp), %rdi
callq 0x41a10
movq -0xc8(%rbp), %rdi
callq 0x57a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x40d01
movl $0xa, -0x14(%rbp)
jmp 0x40d2a
cmpl $0x4, -0x4(%rbp)
jne 0x40d19
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5680
movl %eax, -0x14(%rbp)
jmp 0x40d28
callq 0x3fc90
movl $0x1, %edi
callq 0x54f0
jmp 0x40d2a
leaq -0xa0(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x57b0
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x7c10
jmp 0x40d74
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x40d90
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
movl -0x14(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0x2e8f0
jmp 0x40db9
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x40df2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
jmp 0x40e12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x41a10
movq -0xd0(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0x40e51
movl $0xa, -0x14(%rbp)
jmp 0x40e7a
cmpl $0x5, -0x4(%rbp)
jne 0x40e69
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5680
movl %eax, -0x14(%rbp)
jmp 0x40e78
callq 0x3fce0
movl $0x1, %edi
callq 0x54f0
jmp 0x40e7a
leaq -0xa0(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x110(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x57b0
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x7c10
jmp 0x40ec4
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x40ee0
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
movl -0x14(%rbp), %eax
movl %eax, -0x124(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x120(%rbp)
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x57b0
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
leaq -0xf8(%rbp), %rdi
callq 0x7c10
jmp 0x40f3f
movl -0x124(%rbp), %esi
leaq -0xa0(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0x2eed0
jmp 0x40f5a
leaq -0xf8(%rbp), %rdi
callq 0x58d8
leaq -0xf9(%rbp), %rdi
callq 0x5480
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x40fab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
jmp 0x40ff7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x40feb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x58d8
leaq -0xf9(%rbp), %rdi
callq 0x5480
leaq -0xa0(%rbp), %rdi
callq 0x41a10
movq -0xd0(%rbp), %rdi
callq 0x57a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x41031
movl $0xa, -0x14(%rbp)
jmp 0x4105a
cmpl $0x4, -0x4(%rbp)
jne 0x41049
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5680
movl %eax, -0x14(%rbp)
jmp 0x41058
callq 0x3fd60
movl $0x1, %edi
callq 0x54f0
jmp 0x4105a
leaq -0xa0(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x57b0
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x7c10
jmp 0x410a4
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x410c0
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
movl -0x14(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0x2eb70
jmp 0x410e9
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x41122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
jmp 0x41142
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x41a10
movq -0xd0(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/main.cc
// Function: analogiesSent(int, char**)
void analogiesSent(int argc, char** argv) {
  int32_t k;
  if (argc == 4) {
    k = 10;
  } else if (argc == 5) {
    k = atoi(argv[4]);
  } else {
    printAnalogiesSentUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.analogiesSent(k,std::string(argv[3]));
  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0x41181
movl $0xa, -0x14(%rbp)
jmp 0x411aa
cmpl $0x5, -0x4(%rbp)
jne 0x41199
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5680
movl %eax, -0x14(%rbp)
jmp 0x411a8
callq 0x3fdb0
movl $0x1, %edi
callq 0x54f0
jmp 0x411aa
leaq -0xa0(%rbp), %rdi
callq 0x27dc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x110(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x57b0
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x7c10
jmp 0x411f4
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x295b0
jmp 0x41210
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
movl -0x14(%rbp), %eax
movl %eax, -0x124(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x120(%rbp)
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x57b0
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
leaq -0xf8(%rbp), %rdi
callq 0x7c10
jmp 0x4126f
movl -0x124(%rbp), %esi
leaq -0xa0(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0x2f510
jmp 0x4128a
leaq -0xf8(%rbp), %rdi
callq 0x58d8
leaq -0xf9(%rbp), %rdi
callq 0x5480
xorl %edi, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x412db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x58d8
leaq -0xc1(%rbp), %rdi
callq 0x5480
jmp 0x41327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4131b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x58d8
leaq -0xf9(%rbp), %rdi
callq 0x5480
leaq -0xa0(%rbp), %rdi
callq 0x41a10
movq -0xd0(%rbp), %rdi
callq 0x57a0
nop
// File: epfml[P]Bi-Sent2Vec/src/main.cc
// Function: train(int, char**)
void train(int argc, char** argv) {
  std::shared_ptr<Args> a = std::make_shared<Args>();
  a->parseArgs(argc, argv);
  FastText fasttext;
  fasttext.train(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x342b0
movq -0xd0(%rbp), %rdi
callq 0xe6e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5f50
jmp 0x4137f
leaq -0xb8(%rbp), %rdi
callq 0x27dc0
jmp 0x4138d
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xe060
movq -0xd8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x31a50
jmp 0x413b9
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x41415
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
movq -0x28(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/main.cc
// Function: saveDict(int, char**)
void saveDict(int argc, char** argv) {
  std::shared_ptr<Args> a = std::make_shared<Args>();
  a->parseArgs(argc, argv);
  FastText fasttext;
  fasttext.trainDict(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x342b0
movq -0xd0(%rbp), %rdi
callq 0xe6e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5f50
jmp 0x4146f
leaq -0xb8(%rbp), %rdi
callq 0x27dc0
jmp 0x4147d
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xe060
movq -0xd8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x318b0
jmp 0x414a9
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x41505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
movq -0x28(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: epfml[P]Bi-Sent2Vec/src/main.cc
// Function: trainFromDict(int, char**)
void trainFromDict(int argc, char** argv) {
  std::shared_ptr<Args> a = std::make_shared<Args>();
  a->parseArgs(argc, argv);
  FastText fasttext;
  fasttext.savedDictTrain(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x342b0
movq -0xd0(%rbp), %rdi
callq 0xe6e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5f50
jmp 0x4155f
leaq -0xb8(%rbp), %rdi
callq 0x27dc0
jmp 0x4156d
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xe060
movq -0xd8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x31200
jmp 0x41599
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x415f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xe1b0
leaq -0xb8(%rbp), %rdi
callq 0x41a10
leaq -0x20(%rbp), %rdi
callq 0xe1b0
movq -0x28(%rbp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::run_clustering()
void run_clustering(void) {
			// Step 1: Initialize the centroids using init++
			initialization();

			// set manually a threshold for stoping the algorithm
			int threshold = n_points / 1000;
			// number of changed vector. It is going to change in each itteration
			int changed = INT_MAX;

			// repeat until the threshold is not reached
			while (changed > threshold) {
				// Step 2: call the appropriate method of assignment
				if (assignment_method == "lloyds")
					changed = assignment_lloyds();
				else 
					changed = reverse_assignment();
			
				// Step 3: Update the centroids
				update();
			}
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x143b0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, 0xc(%rsp)
movl $0x7fffffff, 0x8(%rsp)  # imm = 0x7FFFFFFF
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0x6c4d
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x14638(%rip), %rsi     # 0x1b253
callq 0x8790
testb $0x1, %al
jne 0x6c26
jmp 0x6c35
movq (%rsp), %rdi
callq 0x14d20
movl %eax, 0x8(%rsp)
jmp 0x6c42
movq (%rsp), %rdi
callq 0x14e50
movl %eax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0x156d0
jmp 0x6c02
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::get_centroids_map()
std::vector<std::vector<int>> get_centroids_map() {
			// we want to keep a map containing the true values of the vectors, in order to find the median
			std::vector<std::vector<int>> centroids_map(k);
			// insert the vectors in the map
			for (int i = 0; i < n_points; i++) {
				int assigned = assigned_centroid.at(i);
				centroids_map.at(assigned).push_back(i);
			}	
			return centroids_map;
		}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x57(%rsp)
movslq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x199c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x199d0
jmp 0x6d37
leaq 0x56(%rsp), %rdi
callq 0x19a50
movl $0x0, 0x40(%rsp)
movq 0x18(%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x6de8
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movslq 0x40(%rsp), %rsi
callq 0xf110
movq %rax, 0x8(%rsp)
jmp 0x6d75
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movslq 0x3c(%rsp), %rsi
callq 0x6e50
movq %rax, (%rsp)
jmp 0x6d95
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x19a60
jmp 0x6da5
jmp 0x6da7
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x6d49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0x19a50
jmp 0x6e08
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x7ba0
jmp 0x6e08
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x6dfe
movq 0x20(%rsp), %rdi
callq 0x7ba0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::~Clustering()
~Clustering(){
			// free the pointers to the classes in case we have a reverse assignment method selected
			if (assignment_method == "reverse_LSH") 
				delete lsh_instant;
			if (assignment_method == "reverse_Hypercube") 
				delete hc_instant;

		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
leaq 0x1379d(%rip), %rsi     # 0x1b26b
callq 0x8790
testb $0x1, %al
jne 0x7ad9
jmp 0x7b06
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7b04
movq 0x10(%rsp), %rdi
callq 0x1aac0
movq 0x10(%rsp), %rdi
callq 0x21f0
jmp 0x7b06
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0x13778(%rip), %rsi     # 0x1b28e
callq 0x8790
testb $0x1, %al
jne 0x7b21
jmp 0x7b4e
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7b4c
movq 0x8(%rsp), %rdi
callq 0x1ab00
movq 0x8(%rsp), %rdi
callq 0x21f0
jmp 0x7b4e
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0x7a50
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x35b0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x35b0
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x2150
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::assignment_lloyds()
int assignment_lloyds(void) {
			// keep track of the changes in assignments
			int changes = 0;
			// itterate each vector of the dataset
			for (int i = 0; i < n_points; i++) {
				int prev = assigned_centroid.at(i);
				assigned_centroid.at(i) = nearest_centroid(feature_vectors.at(i));
				// check and record changed centroids
				if (prev != assigned_centroid.at(i))
					changes++;
			}

			return changes;
		}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movq 0x20(%rsp), %rcx
movl 0x58(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x14e36
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movslq 0x58(%rsp), %rsi
callq 0xf110
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x54(%rsp)
addq $0x48, %rdi
movslq 0x58(%rsp), %rsi
callq 0x6f30
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x45a0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x16140
movl %eax, 0x1c(%rsp)
jmp 0x14da8
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movslq 0x58(%rsp), %rsi
callq 0xf110
movq %rax, 0x8(%rsp)
jmp 0x14dc2
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x3550
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x60, %rdi
movslq 0x58(%rsp), %rsi
callq 0xf110
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
je 0x14e24
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x14e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3550
jmp 0x14e3f
jmp 0x14e26
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x14d43
movl 0x5c(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2400
nopl (%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::nearest_centroid(std::vector<double, std::allocator<double>>)
int nearest_centroid(vector<T> vec) {
			T min_dist = (T)INT_MAX;
			int nearest = -1;
			// compute the distances to all the centroids
			for (int i = 0; i < k; i++) {
				T dist = metrics::ManhatanDistance(vec, centroids.at(i), space_dim);
				// set it as min
				if (dist < min_dist) {
					min_dist = dist;
					nearest = i;
				}
			}
			assert(nearest != -1);

			return nearest;
		}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x507a(%rip), %xmm0     # 0x1b1e8
movsd %xmm0, 0x70(%rsp)
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x68(%rsp)
movq 0x18(%rsp), %rcx
movl 0x68(%rsp), %eax
cmpl (%rcx), %eax
jge 0x1627a
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x45a0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movslq 0x68(%rsp), %rsi
callq 0x6f30
movq %rax, 0x8(%rsp)
jmp 0x161be
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x45a0
jmp 0x161cf
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x15af0
movsd %xmm0, (%rsp)
jmp 0x161ed
leaq 0x30(%rsp), %rdi
callq 0x3550
leaq 0x48(%rsp), %rdi
callq 0x3550
movsd (%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm1
movsd 0x70(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16268
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x6c(%rsp)
jmp 0x16268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1625c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3550
leaq 0x48(%rsp), %rdi
callq 0x3550
jmp 0x162ae
jmp 0x1626a
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x16184
cmpl $-0x1, 0x6c(%rsp)
je 0x16283
jmp 0x162a2
leaq 0x54bb(%rip), %rdi      # 0x1b745
leaq 0x50f1(%rip), %rsi      # 0x1b382
movl $0x40, %edx
leaq 0x5460(%rip), %rcx      # 0x1b6fd
callq 0x2170
movl 0x6c(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2400
nopl (%rax,%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::min_dist_between_centroids()
T min_dist_between_centroids() {
			// initialize the min distance
			T min_dist = (T)INT_MAX;
			// brute force all the distances in order to find the smallest
			for (int i = 0; i < k; i++) {
				for (int j = 0; j < k; j++) {
					if (i != j) {
						T dist = metrics::ManhatanDistance(centroids.at(i), centroids.at(j), space_dim);
						if (dist < min_dist)
							min_dist = dist;
					}
				}
			} 

			return min_dist;
		}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x4f04(%rip), %xmm0     # 0x1b1e8
movsd %xmm0, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movq 0x20(%rsp), %rcx
movl 0x74(%rsp), %eax
cmpl (%rcx), %eax
jge 0x1642f
movl $0x0, 0x70(%rsp)
movq 0x20(%rsp), %rcx
movl 0x70(%rsp), %eax
cmpl (%rcx), %eax
jge 0x1641d
movl 0x74(%rsp), %eax
cmpl 0x70(%rsp), %eax
je 0x1640b
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x10(%rsp)
movslq 0x74(%rsp), %rsi
callq 0x6f30
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x45a0
movq 0x10(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x6f30
movq %rax, 0x18(%rsp)
jmp 0x16365
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x45a0
jmp 0x16376
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x15af0
movsd %xmm0, 0x8(%rsp)
jmp 0x16395
leaq 0x38(%rsp), %rdi
callq 0x3550
leaq 0x50(%rsp), %rdi
callq 0x3550
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movsd 0x68(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16409
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x78(%rsp)
jmp 0x16409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x163fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3550
leaq 0x50(%rsp), %rdi
callq 0x3550
jmp 0x1643d
jmp 0x1640b
jmp 0x1640d
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x1630b
jmp 0x1641f
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x162f2
movsd 0x78(%rsp), %xmm0
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2400
nopw (%rax,%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::count_unassigned(std::vector<int, std::allocator<int>>)
int count_unassigned(vector<int> assigned) {
			int res = 0;
			for (int i = 0; i < n_points; i++) {
				if (assigned.at(i) == UNASSIGNED) {
					res++;
				}
			}
			
			return res;
		}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x171b7
movq (%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xf110
cmpl $-0x1, (%rax)
jne 0x171a8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x171aa
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1717c
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::second_nearest_centroid(std::vector<double, std::allocator<double>>)
int second_nearest_centroid(vector <T> vec) {
			// get the nearest centroid
			int nearest = nearest_centroid(vec);

			T min_dist = (T)INT_MAX;
			int second_nearest = -1;
			// compute the distances to all the centroids
			for (int i = 0; i < k; i++) {
				T dist = metrics::ManhatanDistance(vec, centroids.at(i), space_dim);
				// set it as min
				if (dist < min_dist && i != nearest) {
					min_dist = dist;
					second_nearest = i;
				}
			}
			assert(second_nearest != -1);

			return second_nearest;
		}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x45a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x16140
movl %eax, 0x2c(%rsp)
jmp 0x1a780
leaq 0x88(%rsp), %rdi
callq 0x3550
movl 0x2c(%rsp), %eax
movl %eax, 0xa4(%rsp)
movsd 0xa48(%rip), %xmm0      # 0x1b1e8
movsd %xmm0, 0x70(%rsp)
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x68(%rsp)
movq 0x18(%rsp), %rcx
movl 0x68(%rsp), %eax
cmpl (%rcx), %eax
jge 0x1a8e6
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x45a0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movslq 0x68(%rsp), %rsi
callq 0x6f30
movq %rax, 0x8(%rsp)
jmp 0x1a7f0
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x45a0
jmp 0x1a801
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x15af0
movsd %xmm0, (%rsp)
jmp 0x1a81f
leaq 0x30(%rsp), %rdi
callq 0x3550
leaq 0x48(%rsp), %rdi
callq 0x3550
movsd (%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm1
movsd 0x70(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a8d4
movl 0x68(%rsp), %eax
cmpl 0xa4(%rsp), %eax
je 0x1a8d4
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x6c(%rsp)
jmp 0x1a8d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3550
jmp 0x1a91a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1a8c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3550
leaq 0x48(%rsp), %rdi
callq 0x3550
jmp 0x1a91a
jmp 0x1a8d6
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x1a7b6
cmpl $-0x1, 0x6c(%rsp)
je 0x1a8ef
jmp 0x1a90e
leaq 0xe48(%rip), %rdi       # 0x1b73e
leaq 0xa85(%rip), %rsi       # 0x1b382
movl $0x55, %edx
leaq 0xe4a(%rip), %rcx       # 0x1b753
callq 0x2170
movl 0x6c(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x2400
nopw (%rax,%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/perf_built_co_sst.cpp
// Function: main
int main(){
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    int n, Q;
    cin >> n >> Q;
    test(n, Q);
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0xa, %edi
callq 0x10d0
callq 0x1140
movq %rax, -0x8(%rbp)
movq 0x39ce(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x1090
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1090
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x53d0
callq 0x1140
movq %rax, -0x18(%rbp)
movq 0x398e(%rip), %rdi      # 0x8fd0
leaq 0xb02(%rip), %rsi       # 0x614b
callq 0x10e0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x56e0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x56b0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5730
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x11c0
movq %rax, %rdi
leaq 0xacf(%rip), %rsi       # 0x615e
callq 0x10e0
movq %rax, %rdi
movq 0x3922(%rip), %rsi      # 0x8fc0
callq 0x1120
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/test/SignalTest.cpp
// Function: SignalTest_MetaTest_Test::TestBody()
TEST_F(SignalTest, MetaTest){
    cout << "Instantiating signal object" << endl;

    Signal<int, int> testSignal;
    cout << "Size of signal: " << sizeof(testSignal) << endl;
    BSignals::details::MPSCQueue<std::function<void()>> mpscQ;
    cout << "Size of MPSCQ: " << sizeof(mpscQ) << endl;
    
    auto dur = BSignals::details::WheeledThreadPool::getMaxWait();
    cout << "Max wait: " << std::chrono::duration<double, std::nano>(dur).count() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x510, %rsp            # imm = 0x510
movq %rdi, -0x8(%rbp)
movq 0xe3202(%rip), %rdi     # 0xfafb8
movq %rdi, -0x4d0(%rbp)
leaq 0x8d8fb(%rip), %rsi     # 0xa56bf
callq 0xd640
movq %rax, %rdi
movq 0xe31bd(%rip), %rsi     # 0xfaf90
callq 0xd6e0
leaq -0x120(%rbp), %rdi
callq 0x1c140
movq -0x4d0(%rbp), %rdi
leaq 0x8d8e9(%rip), %rsi     # 0xa56db
callq 0xd640
movq %rax, -0x4c8(%rbp)
jmp 0x17e00
movq -0x4c8(%rbp), %rdi
movl $0x118, %esi            # imm = 0x118
callq 0xd130
movq %rax, -0x4d8(%rbp)
jmp 0x17e1a
movq -0x4d8(%rbp), %rdi
movq 0xe3168(%rip), %rsi     # 0xfaf90
callq 0xd6e0
jmp 0x17e2f
leaq -0x4b0(%rbp), %rdi
callq 0x1c160
jmp 0x17e3d
movq 0xe3174(%rip), %rdi     # 0xfafb8
leaq 0x8d8a1(%rip), %rsi     # 0xa56ec
callq 0xd640
movq %rax, -0x4e0(%rbp)
jmp 0x17e59
movq -0x4e0(%rbp), %rdi
movl $0x380, %esi            # imm = 0x380
callq 0xd130
movq %rax, -0x4e8(%rbp)
jmp 0x17e73
movq -0x4e8(%rbp), %rdi
movq 0xe310f(%rip), %rsi     # 0xfaf90
callq 0xd6e0
jmp 0x17e88
callq 0x118a0
movsd %xmm0, -0x4f0(%rbp)
jmp 0x17e97
movsd -0x4f0(%rbp), %xmm0
movsd %xmm0, -0x4b8(%rbp)
movq 0xe310a(%rip), %rdi     # 0xfafb8
leaq 0x8d847(%rip), %rsi     # 0xa56fc
callq 0xd640
movq %rax, -0x4f8(%rbp)
jmp 0x17ec3
leaq -0x4c0(%rbp), %rdi
leaq -0x4b8(%rbp), %rsi
callq 0xff90
jmp 0x17ed8
leaq -0x4c0(%rbp), %rdi
callq 0xffd0
movsd %xmm0, -0x500(%rbp)
jmp 0x17eee
movsd -0x500(%rbp), %xmm0
movq -0x4f8(%rbp), %rdi
callq 0xddc0
movq %rax, -0x508(%rbp)
jmp 0x17f0b
movq -0x508(%rbp), %rdi
movq 0xe3077(%rip), %rsi     # 0xfaf90
callq 0xd6e0
jmp 0x17f20
leaq -0x4b0(%rbp), %rdi
callq 0x1c240
leaq -0x120(%rbp), %rdi
callq 0x1c2f0
addq $0x510, %rsp            # imm = 0x510
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x17f73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x1c240
leaq -0x120(%rbp), %rdi
callq 0x1c2f0
movq -0x128(%rbp), %rdi
callq 0xdcb0
nopl (%rax,%rax)