LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
callq 0x1a272
cmpl $0x2, %ebp
jg 0x1c191
callq 0x1be28
movq (%rsp), %rdi
callq 0x5836
movl $0x1, %edi
callq 0x4380
movq (%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4ea2
leaq 0x20(%rsp), %rdi
callq 0x11bdc
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x1c1d6
movq 0xddf0(%rip), %rcx      # 0x29fb8
cmpb $0x0, (%rcx)
jne 0x1c1d3
lock
incl 0x8(%rax)
jmp 0x1c1d6
incl 0x8(%rax)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x13ea0
leaq 0x10(%rsp), %rdi
callq 0x1dcb2
xorl %edi, %edi
callq 0x4380
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1c208
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1c21a
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1c229
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1c238
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1c247
callq 0xa86c
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1c256
callq 0xa86c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1c265
callq 0xa86c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1c27b
callq 0xa86c
jmp 0x1c27b
jmp 0x1c278
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c28a
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c508
callq 0x1be6c
movl $0x1, %edi
callq 0x4380
movq %rsi, %r14
movl $0x1, %ebx
cmpl $0x5, %edi
jl 0x1c520
movq 0x20(%r14), %rdi
callq 0x44c0
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x10(%r14), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x617a
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c57a
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x617a
leaq 0x3421(%rip), %rsi      # 0x1f9b8
leaq 0x8(%rsp), %rdi
callq 0x40e0
testl %eax, %eax
jne 0x1c5bf
movq 0xda2c(%rip), %rsi      # 0x29fd8
leaq 0x28(%rsp), %rdi
movl %ebx, %edx
callq 0x14e6a
xorl %edi, %edi
callq 0x4380
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x44f0
leaq 0x128(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x1c617
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl %ebx, %edx
callq 0x14e6a
leaq 0xb0(%rsp), %rdi
callq 0x4090
leaq 0xb0(%rsp), %rdi
callq 0x40c0
jmp 0x1c5b8
movq 0xd9d2(%rip), %rdi      # 0x29ff0
leaq 0x40a8(%rip), %rsi      # 0x206cd
movl $0x1b, %edx
callq 0x4350
movq 0xd9ba(%rip), %rdi      # 0x29ff0
callq 0x4170
jmp 0x1c4fe
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x40c0
jmp 0x1c657
jmp 0x1c654
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c697
movq 0x18(%rsp), %rsi
jmp 0x1c68a
jmp 0x1c694
movq %rax, %rbx
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c697
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1c697
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6a9
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6bb
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6ca
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6d9
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6e8
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6f7
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1c706
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c9f7
movq %rsi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x617a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c9e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x28(%rsp), %rdi
callq 0x16416
xorl %edi, %edi
callq 0x4380
callq 0x1bf6c
movl $0x1, %edi
callq 0x4380
jmp 0x1ca28
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ca2b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1ca2b
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca3d
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca4f
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca5e
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca6d
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca7c
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca8b
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca9a
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cb11
movq %rsi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x617a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cb00
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x28(%rsp), %rdi
callq 0x166c2
xorl %edi, %edi
callq 0x4380
callq 0x1bfc4
movl $0x1, %edi
callq 0x4380
jmp 0x1cb42
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cb45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1cb45
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb57
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb69
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb78
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb87
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb96
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1cba5
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1cbb4
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cc8c
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
leaq 0x30(%rsp), %r14
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x617a
leaq 0x14ac(%rip), %rsi      # 0x1e09b
movq %r14, %rdi
callq 0x40e0
testl %eax, %eax
je 0x1cc14
leaq 0x14a6(%rip), %rsi      # 0x1e0a8
leaq 0x30(%rsp), %rdi
callq 0x40e0
testl %eax, %eax
jne 0x1cc9b
leaq 0x50(%rsp), %rdi
callq 0x11bdc
movq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617a
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cc62
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x1432(%rip), %rsi      # 0x1e09b
leaq 0x30(%rsp), %rdi
callq 0x40e0
xorl %esi, %esi
testl %eax, %eax
sete %sil
leaq 0x50(%rsp), %rdi
callq 0x1641c
xorl %edi, %edi
callq 0x4380
callq 0x1c01c
movl $0x1, %edi
callq 0x4380
callq 0x1c01c
jmp 0x1cc91
jmp 0x1ccc6
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ccc9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1ccc9
jmp 0x1cd40
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ccdb
callq 0xa86c
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cced
callq 0xa86c
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1ccff
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd11
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd20
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd2f
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd43
callq 0xa86c
jmp 0x1cd43
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cd5e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]Bi-Sent2Vec/src/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 %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
cmpl $0x3, %edi
jne 0x1cdf6
movq %rsi, %rbx
leaq 0x38(%rsp), %rdi
callq 0x11bdc
movq 0x10(%rbx), %rsi
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x617a
leaq 0x38(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cdc8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x11c02
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x11c14
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
jne 0x1ce05
xorl %edi, %edi
callq 0x4380
callq 0x1c088
movl $0x1, %edi
callq 0x4380
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0xd1ab(%rip), %rbx      # 0x29fc0
leaq 0x1d46(%rip), %r14      # 0x1eb62
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x4350
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4350
movq 0x20(%rsp), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0x42c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4200
incq %r13
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %r13, %rcx
ja 0x1ce1c
jmp 0x1cdef
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1cebb
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
jmp 0x1cebb
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa654
jmp 0x1ceea
jmp 0x1cee7
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ceea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1ceea
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1cefc
callq 0xa86c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf0e
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf20
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf2f
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf3e
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf4d
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf5c
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cff9
movq %rsi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11bdc
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x617a
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cfc6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x18(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x617a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x159e6
leaq 0x28(%rsp), %rdi
callq 0x4698
xorl %edi, %edi
callq 0x4380
callq 0x1c0e0
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d045
movq 0x38(%rsp), %rsi
jmp 0x1d038
jmp 0x1d042
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d045
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1d045
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x1d057
callq 0xa86c
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1d069
callq 0xa86c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1d07b
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d08d
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1d09c
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1d0ab
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1d0ba
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d0e6
cmpl $0x4, %edi
jne 0x1d14c
movq 0x18(%r14), %rdi
callq 0x44c0
movl %eax, %ebx
jmp 0x1d0eb
movl $0xa, %ebx
leaq 0x30(%rsp), %rdi
callq 0x11bdc
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d139
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x1718a
xorl %edi, %edi
callq 0x4380
callq 0x1c292
movl $0x1, %edi
callq 0x4380
jmp 0x1d17d
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d180
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1d180
movq %rax, %rbx
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1d192
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1a4
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1b3
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1c2
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1d1
callq 0xa86c
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1e0
callq 0xa86c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1ef
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d21f
cmpl $0x5, %edi
jne 0x1d2a7
movq 0x20(%r14), %rdi
callq 0x44c0
movl %eax, %ebx
jmp 0x1d224
movl $0xa, %ebx
leaq 0x50(%rsp), %rdi
callq 0x11bdc
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617a
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d272
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x18(%r14), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x617a
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %ebx, %esi
callq 0x175f0
leaq 0x30(%rsp), %rdi
callq 0x4698
xorl %edi, %edi
callq 0x4380
callq 0x1c2fe
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d2f3
movq 0x40(%rsp), %rsi
jmp 0x1d2e6
jmp 0x1d2f0
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d2f3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1d2f3
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d305
callq 0xa86c
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d317
callq 0xa86c
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1d329
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1d33b
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d34a
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d359
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1d368
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d394
cmpl $0x4, %edi
jne 0x1d3fa
movq 0x18(%r14), %rdi
callq 0x44c0
movl %eax, %ebx
jmp 0x1d399
movl $0xa, %ebx
leaq 0x30(%rsp), %rdi
callq 0x11bdc
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d3e7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x17392
xorl %edi, %edi
callq 0x4380
callq 0x1c3c0
movl $0x1, %edi
callq 0x4380
jmp 0x1d42b
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d42e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1d42e
movq %rax, %rbx
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1d440
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1d452
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d461
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d470
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1d47f
callq 0xa86c
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1d48e
callq 0xa86c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1d49d
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
cmpl $0x4, %edi
je 0x1d4cd
cmpl $0x5, %edi
jne 0x1d555
movq 0x20(%r14), %rdi
callq 0x44c0
movl %eax, %ebx
jmp 0x1d4d2
movl $0xa, %ebx
leaq 0x50(%rsp), %rdi
callq 0x11bdc
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617a
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1315e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d520
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x18(%r14), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x617a
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %ebx, %esi
callq 0x17b32
leaq 0x30(%rsp), %rdi
callq 0x4698
xorl %edi, %edi
callq 0x4380
callq 0x1c42c
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d5a1
movq 0x40(%rsp), %rsi
jmp 0x1d594
jmp 0x1d59e
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d5a1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x1d5a1
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5b3
callq 0xa86c
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5c5
callq 0xa86c
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5d7
callq 0xa86c
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5e9
callq 0xa86c
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5f8
callq 0xa86c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d607
callq 0xa86c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1d616
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x1a272
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4ea2
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1d692
movq 0xc934(%rip), %rcx      # 0x29fb8
cmpb $0x0, (%rcx)
je 0x1d68e
incl 0x8(%rax)
jmp 0x1d692
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x19478
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6b0
callq 0xa86c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6c2
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6d4
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6e3
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6f2
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1d701
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1d710
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d71f
callq 0xa86c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d72e
callq 0xa86c
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d74c
callq 0xa86c
leaq 0x28(%rsp), %rdi
callq 0x1dcc0
jmp 0x1d75d
jmp 0x1d75a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d76c
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x1a272
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4ea2
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1d7e8
movq 0xc7de(%rip), %rcx      # 0x29fb8
cmpb $0x0, (%rcx)
je 0x1d7e4
incl 0x8(%rax)
jmp 0x1d7e8
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1933e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d806
callq 0xa86c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1d818
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d82a
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1d839
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1d848
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1d857
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1d866
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d875
callq 0xa86c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d884
callq 0xa86c
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d8a2
callq 0xa86c
leaq 0x28(%rsp), %rdi
callq 0x1dcc0
jmp 0x1d8b3
jmp 0x1d8b0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d8c2
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x1a272
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4ea2
leaq 0x28(%rsp), %rdi
callq 0x11bdc
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1d93e
movq 0xc688(%rip), %rcx      # 0x29fb8
cmpb $0x0, (%rcx)
je 0x1d93a
incl 0x8(%rax)
jmp 0x1d93e
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x18efe
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d95c
callq 0xa86c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1d96e
callq 0xa86c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d980
callq 0xa86c
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1d98f
callq 0xa86c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1d99e
callq 0xa86c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9ad
callq 0xa86c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9bc
callq 0xa86c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9cb
callq 0xa86c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9da
callq 0xa86c
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9f8
callq 0xa86c
leaq 0x28(%rsp), %rdi
callq 0x1dcc0
jmp 0x1da09
jmp 0x1da06
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1da18
callq 0xa86c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::Clustering(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, unsigned int)
Clustering(std::string assignment_method, std::vector<std::vector<T>> feature_vectors, uint32_t k)
		: feature_vectors(feature_vectors), k(k) {
			if (assignment_method != "lloyds") {
				cout << "Wrong assignment method selected\n";
				exit(EXIT_FAILURE);
			}
			// initialize all the classs fields necessary
			this->assignment_method = assignment_method;
			n_points = feature_vectors.size();
			assert(n_points);
			space_dim = feature_vectors.at(0).size();

			vector<int> assigned(n_points, 0);
			assigned_centroid = assigned;

		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl %ecx, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4574
leaq 0x60(%r14), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movq $0x0, 0x70(%r14)
leaq 0x6c1c(%rip), %rsi      # 0xb28b
movq %rbp, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x4712
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2160
movq (%r13), %rax
movq 0x8(%r13), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
movl %edx, 0x4(%r14)
testl %edx, %edx
je 0x472f
cmpq %rax, %rcx
je 0x474e
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
movl %ecx, 0x8(%r14)
movslq %edx, %rsi
leaq 0x1c(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x578a
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x58fe
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4703
callq 0x2260
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb8bf(%rip), %rdi      # 0xffd8
leaq 0x6c99(%rip), %rsi      # 0xb3b9
callq 0x2280
movl $0x1, %edi
callq 0x22e0
leaq 0x6ca5(%rip), %rdi      # 0xb3db
leaq 0x6ca7(%rip), %rsi      # 0xb3e4
leaq 0x6cdd(%rip), %rcx      # 0xb421
movl $0x83, %edx
callq 0x21a0
leaq 0x6bf0(%rip), %rdi      # 0xb345
xorl %esi, %esi
xorl %eax, %eax
callq 0x2370
movq %rax, %r13
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x477c
callq 0x2260
jmp 0x477c
jmp 0x4779
movq %rax, %r13
jmp 0x4792
movq %rax, %r13
movq (%r12), %rdi
testq %rdi, %rdi
je 0x478a
callq 0x2260
movq %r15, %rdi
callq 0x3618
addq $0x30, %r14
movq %r14, %rdi
callq 0x3618
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x47ad
callq 0x2260
movq %r13, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8416
movslq 0x4(%rbx), %rax
imulq $0x10624dd3, %rax, %r12 # imm = 0x10624DD3
movq %r12, %rax
shrq $0x3f, %rax
sarq $0x26, %r12
addl %eax, %r12d
leaq 0x10(%rbx), %r14
leaq 0x65b5(%rip), %r15      # 0xb28b
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
movq %rbx, %rdi
testl %eax, %eax
je 0x4cef
callq 0x8b0c
jmp 0x4cf4
callq 0x89e4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x9220
cmpl %r12d, %ebp
jg 0x4cd6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0xa688
movl $0x0, (%rsp)
cmpl $0x0, 0x4(%r14)
jle 0x4daa
xorl %eax, %eax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsp, %r15
movslq %eax, %rsi
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x4db9
movslq (%rcx,%rsi,4), %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x4db9
leaq (%rsi,%rsi,2), %rdx
leaq (%rcx,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4d94
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4d9c
movq %r15, %rdx
callq 0xa736
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
cmpl 0x4(%r14), %eax
jl 0x4d44
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6585(%rip), %rdi      # 0xb345
xorl %eax, %eax
callq 0x2370
jmp 0x4dc9
movq %rax, %r14
movq %rbx, %rdi
callq 0x5630
movq %r14, %rdi
callq 0x2450
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x5d1a(%rip), %rsi      # 0xb2a3
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x55c4
movq 0x80(%rbx), %r15
testq %r15, %r15
je 0x55c4
leaq 0x50(%r15), %rdi
callq 0x3618
leaq 0x38(%r15), %rdi
callq 0x618a
leaq 0x20(%r15), %rdi
callq 0x702a
movq %r15, %rdi
callq 0x2260
leaq 0x5cfb(%rip), %rsi      # 0xb2c6
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x55f3
movq 0x98(%rbx), %r14
testq %r14, %r14
je 0x55f3
movq %r14, %rdi
callq 0xaa06
movq %r14, %rdi
callq 0x2260
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x5601
callq 0x2260
leaq 0x48(%rbx), %rdi
callq 0x3618
leaq 0x30(%rbx), %rdi
callq 0x3618
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x562a
popq %rbx
popq %r14
popq %r15
jmp 0x2260
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x4(%rdi)
jle 0x8abb
movq %rdi, %r14
xorl %r12d, %r12d
movq %rsp, %r15
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x60(%r14), %rax
movq 0x68(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x8ace
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x8ace
movl (%rax,%rbx,4), %r13d
addq %r12, %rsi
movq %r15, %rdi
callq 0x3900
movq %r14, %rdi
movq %r15, %rsi
callq 0x969e
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x8adf
movl %eax, (%rcx,%rbx,4)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8a86
callq 0x2260
movq 0x60(%r14), %rax
movq 0x68(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x8ace
xorl %ecx, %ecx
cmpl (%rax,%rbx,4), %r13d
setne %cl
addl %ecx, %ebp
incq %rbx
movslq 0x4(%r14), %rax
addq $0x18, %r12
cmpq %rax, %rbx
jl 0x8a09
jmp 0x8abd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2870(%rip), %rdi      # 0xb345
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0x285f(%rip), %rdi      # 0xb345
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2370
jmp 0x8af2
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8b03
callq 0x2260
movq %rbx, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, (%rdi)
jle 0x97ba
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movsd 0x1b38(%rip), %xmm0     # 0xb200
xorl %r14d, %r14d
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %rbp
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x3900
movq 0x30(%r12), %rax
movq 0x38(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r14, %rdx
jbe 0x97d5
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %rbp, %rdi
callq 0x3900
movslq 0x8(%r12), %rax
testq %rax, %rax
movapd 0x1ae2(%rip), %xmm1     # 0xb210
jle 0x975c
movq 0x18(%rsp), %rcx
xorpd %xmm2, %xmm2
movq 0x30(%rsp), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
subsd (%rdx,%rsi,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rsi
cmpq %rsi, %rax
jne 0x9740
jmp 0x9760
xorpd %xmm2, %xmm2
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
movsd %xmm2, 0x8(%rsp)
je 0x977b
callq 0x2260
movsd 0x8(%rsp), %xmm2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
movsd 0x10(%rsp), %xmm0
je 0x979c
callq 0x2260
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
cmovbl %r14d, %ebx
minsd %xmm2, %xmm0
incq %r14
movslq (%r12), %rax
cmpq %rax, %r14
jl 0x96d5
jmp 0x97bf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebx
je 0x97e6
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b69(%rip), %rdi      # 0xb345
movq %r14, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0x1fba(%rip), %rdi      # 0xb7a7
leaq 0x1bf0(%rip), %rsi      # 0xb3e4
leaq 0x1f64(%rip), %rcx      # 0xb75f
movl $0x40, %edx
callq 0x21a0
jmp 0x9807
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9819
callq 0x2260
movq %rbx, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, (%rdi)
jle 0x996d
movq %rdi, %r14
movsd 0x19bc(%rip), %xmm0     # 0xb200
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x30(%rsp), %r12
cmpl $0x0, (%r14)
jle 0x995c
leaq (%rbx,%rbx,2), %r15
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x994d
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
cmpq %rbx, %rdx
jbe 0x9984
movsd %xmm0, 0x10(%rsp)
leaq (%rax,%r15,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3900
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
cmpq %r13, %rdx
jbe 0x9995
leaq (,%r13,2), %rcx
addq %r13, %rcx
leaq (%rax,%rcx,8), %rsi
movq %r12, %rdi
callq 0x3900
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x990f
movq 0x18(%rsp), %rcx
xorpd %xmm2, %xmm2
movq 0x30(%rsp), %rdx
xorl %esi, %esi
movapd 0x191d(%rip), %xmm1     # 0xb210
movsd (%rcx,%rsi,8), %xmm0
subsd (%rdx,%rsi,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rsi
cmpq %rsi, %rax
jne 0x98f3
jmp 0x9913
xorpd %xmm2, %xmm2
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
movsd %xmm2, 0x8(%rsp)
je 0x992e
callq 0x2260
movsd 0x8(%rsp), %xmm2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9943
callq 0x2260
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
minsd %xmm2, %xmm0
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x9866
incq %rbx
movslq (%r14), %rax
cmpq %rax, %rbx
jl 0x9855
jmp 0x9975
movsd 0x188b(%rip), %xmm0     # 0xb200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19ba(%rip), %rdi      # 0xb345
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0x19a9(%rip), %rdi      # 0xb345
movq %r13, %rsi
xorl %eax, %eax
callq 0x2370
jmp 0x99a8
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x99ba
callq 0x2260
movq %rbx, %rdi
callq 0x2450
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movslq 0x4(%rdi), %rcx
testq %rcx, %rcx
jle 0xa22e
movq (%rsi), %rdi
movq 0x8(%rsi), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
leal -0x1(%rcx), %esi
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %rsi, %rdx
jbe 0xa232
xorl %r9d, %r9d
cmpl $-0x1, (%rdi,%r8,4)
sete %r9b
addl %r9d, %eax
incq %r8
cmpq %r8, %rcx
jne 0xa210
jmp 0xa230
xorl %eax, %eax
popq %rcx
retq
leaq 0x110c(%rip), %rdi      # 0xb345
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x3900
movq %r14, %rdi
movq %r15, %rsi
callq 0x969e
movl %eax, %ebp
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xa88b
callq 0x2260
cmpl $0x0, (%r14)
jle 0xa994
movl %ebp, %r12d
movsd 0x960(%rip), %xmm0      # 0xb200
movsd %xmm0, (%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq 0x28(%rsp), %r13
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x3900
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0xa9af
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r13, %rdi
callq 0x3900
movslq 0x8(%r14), %rax
testq %rax, %rax
movapd 0x90c(%rip), %xmm1      # 0xb210
jle 0xa932
movq 0x10(%rsp), %rcx
xorpd %xmm2, %xmm2
movq 0x28(%rsp), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
subsd (%rdx,%rsi,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rsi
cmpq %rsi, %rax
jne 0xa916
jmp 0xa936
xorpd %xmm2, %xmm2
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
movsd %xmm2, 0x8(%rsp)
je 0xa951
callq 0x2260
movsd 0x8(%rsp), %xmm2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa966
callq 0x2260
movsd 0x8(%rsp), %xmm2
ucomisd (%rsp), %xmm2
setae %al
cmpq %r12, %r15
sete %cl
orb %al, %cl
testb %cl, %cl
jne 0xa97f
movsd %xmm2, (%rsp)
cmovel %r15d, %ebp
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0xa8b2
jmp 0xa999
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
je 0xa9c0
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x98f(%rip), %rdi       # 0xb345
movq %r15, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0xdd9(%rip), %rdi       # 0xb7a0
leaq 0xa16(%rip), %rsi       # 0xb3e4
leaq 0xde0(%rip), %rcx       # 0xb7b5
movl $0x55, %edx
callq 0x21a0
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa9f3
jmp 0xa9eb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa9fd
callq 0x2260
movq %rbx, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xa, %edi
callq 0x10f0
callq 0x1160
movq %rax, %rbx
movq 0x24a7(%rip), %rdi      # 0x4fe0
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x10a0
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a0
movl (%r14), %edi
movl (%r15), %esi
callq 0x2938
callq 0x1160
movq %rax, %r14
movq 0x2460(%rip), %r15      # 0x4fd0
leaq 0x622(%rip), %rsi       # 0x3199
movl $0x12, %edx
movq %r15, %rdi
callq 0x1140
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0x5f5(%rip), %rsi       # 0x31ac
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/test/SafeQueue.hpp
// Function: BSignals::details::SafeQueue<BigThing>::enqueue(BigThing const&)
void enqueue(const T &t){
        std::unique_lock<std::mutex> lock(m);
        q.push(t);
        lock.unlock();
        c.notify_one();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x258(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0xd7bc
movb $0x1, 0x8(%r15)
movq 0x238(%rbx), %rdi
movq $-0x200, %rax           # imm = 0xFE00
addq 0x248(%rbx), %rax
cmpq %rax, %rdi
je 0x11e8a
movl $0x200, %edx            # imm = 0x200
movq %r14, %rsi
callq 0xb430
addq $0x200, 0x238(%rbx) # imm = 0x200
jmp 0x11e99
leaq 0x208(%rbx), %rdi
movq %r14, %rsi
callq 0x1557a
movq %rsp, %rdi
callq 0xd7f8
addq $0x280, %rbx            # imm = 0x280
movq %rbx, %rdi
callq 0xb280
movq %rsp, %rdi
callq 0xd7a6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd7a6
movq %rbx, %rdi
callq 0xba10
nop