LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/utilities.cpp
// Function: getCimapFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
cimap getCimapFromString(std::string str) {
  cimap m;
  vector<string> tokenized = tokenize(str, '&');
  for (auto token : tokenized) {
    vector<string> keyValue = tokenize(token, '=');
    if (keyValue.size() != 2)
      continue;
    string key = keyValue[0];
    string value = keyValue[1];
    m[key] = value;
  }
  return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movq %rcx, 0x28(%rdi)
leaq -0xa0(%rbp), %rdi
movl $0x26, %edx
callq 0xf646
movq -0xa0(%rbp), %r12
movq -0x98(%rbp), %r13
cmpq %r13, %r12
je 0xfa14
leaq -0xb0(%rbp), %rbx
leaq -0xc0(%rbp), %r14
leaq -0x88(%rbp), %r15
movq %rbx, -0xc0(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x7dfa
movq %r15, %rdi
movq %r14, %rsi
movl $0x3d, %edx
callq 0xf646
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rax, %rcx
cmpq $0x40, %rcx
jne 0xf9ee
leaq -0x60(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x7dfa
movq -0x88(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x7dfa
movq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa8c0
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x4220
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xf9dc
callq 0x4310
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xf9ee
callq 0x4310
movq %r15, %rdi
callq 0xe90a
movq -0xc0(%rbp), %rdi
cmpq %rbx, %rdi
je 0xfa07
callq 0x4310
addq $0x20, %r12
cmpq %r13, %r12
jne 0xf934
leaq -0xa0(%rbp), %rdi
callq 0xe90a
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xfa9f
movq %rax, %r14
jmp 0xfa76
movq %rax, %r14
jmp 0xfa64
movq %rax, %r14
jmp 0xfa93
movq %rax, %r14
jmp 0xfa82
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xfa64
callq 0x4310
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xfa76
callq 0x4310
leaq -0x88(%rbp), %rdi
callq 0xe90a
movq -0xc0(%rbp), %rdi
cmpq %rbx, %rdi
je 0xfa93
callq 0x4310
leaq -0xa0(%rbp), %rdi
callq 0xe90a
movq -0x30(%rbp), %rdi
callq 0xa9f2
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/utilities.cpp
// Function: readMapFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
int readMapFromFile(std::string fname, std::map<std::string, std::string> *m) {
  std::ifstream inputStream(fname);
  if (!inputStream.is_open())
    return -errno;

  std::string line;
  while (std::getline(inputStream, line)) {
    auto tokens = tokenize(line, '=');
    //     KEY         VALUE
    (*m)[tokens[0]] = tokens[(tokens.size() < 2) ? 0 : 1];
  }

  inputStream.close();
  return (*m).size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, -0x30(%rbp)
movq %rdi, %rsi
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x4520
leaq -0x1f8(%rbp), %rdi
callq 0x40d0
testb %al, %al
je 0xfb8b
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %r15
leaq -0x68(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x45e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xfb96
movq %r12, %rdi
movq %r15, %rsi
movl $0x3d, %edx
callq 0xf646
movq -0x68(%rbp), %r13
movq -0x60(%rbp), %rbx
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xfc16
subq %r13, %rbx
xorl %esi, %esi
cmpq $0x21, %rbx
setae %sil
shll $0x5, %esi
addq %r13, %rsi
movq %rax, %rdi
callq 0x4220
movq %r12, %rdi
callq 0xe90a
jmp 0xfb0e
callq 0x4060
xorl %ebx, %ebx
subl (%rax), %ebx
jmp 0xfbbb
leaq -0x270(%rbp), %rdi
callq 0x40b0
movq -0x30(%rbp), %rax
movl 0x28(%rax), %ebx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xfbbb
callq 0x4310
leaq -0x270(%rbp), %rdi
callq 0x40f0
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfbed
jmp 0xfbed
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xe90a
jmp 0xfbf0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xfc02
callq 0x4310
leaq -0x270(%rbp), %rdi
callq 0x40f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split(string str, string separator, int max, vector<string> &results) {
  int i = 0;
  size_t found = str.find_first_of(separator);

  while (found != string::npos) {
    if (found > 0)
      results.push_back(str.substr(0, found));
    str = str.substr(found + 1);
    found = str.find_first_of(separator);

    if (max > -1 && ++i == max)
      break;
  }
  if (str.length() > 0)
    results.push_back(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x38(%rbp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%r12), %rcx
movq $0x0, -0x30(%rbp)
xorl %edx, %edx
callq 0x44d0
movq %rax, %rbx
leaq -0x58(%rbp), %r13
testq %rbx, %rbx
je 0xff35
cmpq $-0x1, %rbx
je 0xff9c
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x4370
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x149b4
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xff35
callq 0x4310
incq %rbx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x4370
movq %r14, %rdi
movq %r13, %rsi
callq 0x4400
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xff6a
callq 0x4310
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44d0
movq %rax, %rbx
testl %r15d, %r15d
js 0xfef8
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
cmpl %r15d, %eax
jne 0xfef8
cmpq $0x0, 0x8(%r14)
je 0xffaf
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xe962
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xffd3
callq 0x4310
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: Server::~Server()
Server::~Server() {
  if (sc >= 0)
    CLOSESOCKET(sc);
  delete notFoundHandler;
  for (size_t i = 0; i < routes.size(); ++i)
    delete routes[i];

#ifdef _WIN32
  WSACleanup();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
js 0x13870
callq 0x4600
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1387f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
cmpq %rdi, 0x10(%rbx)
je 0x138bc
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x1389d
movq %r14, %rdi
callq 0x14da6
movq %r14, %rdi
callq 0x4310
incq %r15
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %r15
jb 0x1388c
addq $0x8, %rsp
testq %rdi, %rdi
je 0x138d0
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4310
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x6f48
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: ShowFile::callback(Request*)
Response *ShowFile::callback(Request *req) {
  Response *res = new Response;
  res->setHeader("Content-Type", fileType);
  res->setBody(readFile(filePath.c_str()));
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movl $0x78, %edi
callq 0x4350
movq %rax, %rbx
movq %rax, %rdi
movl $0xc8, %esi
callq 0x82ca
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5768(%rip), %rsi      # 0x19175
leaq 0x576d(%rip), %rdx      # 0x19181
leaq -0x60(%rbp), %rdi
callq 0x6f56
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x7dfa
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0xa3f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13a58
callq 0x4310
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x13a66
callq 0x4310
movq 0x8(%r14), %rsi
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xf119
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa414
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13a93
callq 0x4310
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x13adc
jmp 0x13ae1
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13acb
callq 0x4310
jmp 0x13acb
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
jne 0x13adc
jmp 0x13ae1
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: TemplateHandler::callback(Request*)
Response *TemplateHandler::callback(Request *req) {
  map<string, string> context;
  context = this->handle(req);
  Response *res = new Response;
  res->setHeader("Content-Type", "text/html");
  res->setBody(parser->getHtml(context));
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rdx
movq %rdi, %r14
leaq -0x48(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq (%rdi), %rax
leaq -0x110(%rbp), %rdi
movq %r14, %rsi
callq *0x18(%rax)
leaq -0x50(%rbp), %rdi
callq 0x14770
movq -0x100(%rbp), %rax
testq %rax, %rax
je 0x14007
leaq -0x108(%rbp), %rcx
movl (%rcx), %edx
movl %edx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movups 0x10(%rcx), %xmm0
movups %xmm0, -0x38(%rbp)
movq %rbx, 0x8(%rax)
movq 0x20(%rcx), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x110(%rbp), %rdi
callq 0x7d60
movl $0x78, %edi
callq 0x4350
movq %rax, %rbx
movq %rax, %rdi
movl $0xc8, %esi
callq 0x82ca
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5139(%rip), %rsi      # 0x19175
leaq 0x513e(%rip), %rdx      # 0x19181
leaq -0x90(%rbp), %rdi
callq 0x6f56
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x5123(%rip), %rsi      # 0x19182
leaq 0x5125(%rip), %rdx      # 0x1918b
leaq -0x70(%rbp), %rdi
callq 0x6f56
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rdi
callq 0xa3f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x14090
callq 0x4310
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x140a1
callq 0x4310
movq 0x28(%r14), %r14
leaq -0xe0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x147a8
leaq -0xb0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
movq %r14, %rsi
callq 0x153a4
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0xa414
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x140ef
callq 0x4310
leaq -0xe0(%rbp), %rdi
callq 0x7d60
leaq -0x50(%rbp), %rdi
callq 0x7d60
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14134
callq 0x4310
jmp 0x14134
movq %rax, %r14
leaq -0xe0(%rbp), %rdi
callq 0x7d60
jmp 0x1417a
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x14158
callq 0x4310
jmp 0x14158
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
jne 0x1416e
jmp 0x1417a
jmp 0x14177
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
jmp 0x1417a
jmp 0x14177
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x7d60
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: ServerErrorHandler::callback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static Response *callback(string msg) {
    Response *res = new Response(500);
    res->setHeader("Content-Type", "application/json");
    res->setBody("{ \"code\": \"500\", \"message\": \"" + msg + "\" }\n");
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
movl $0x78, %edi
callq 0x4350
movq %rax, %rbx
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x82ca
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4f0b(%rip), %rsi      # 0x19175
leaq 0x4f10(%rip), %rdx      # 0x19181
leaq -0x80(%rbp), %rdi
callq 0x6f56
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x5571(%rip), %rsi      # 0x197fb
leaq 0x557a(%rip), %rdx      # 0x1980b
leaq -0x60(%rbp), %rdi
callq 0x6f56
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0xa3f0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x142b8
callq 0x4310
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x142c6
callq 0x4310
leaq 0x553f(%rip), %rsi      # 0x1980c
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xa7d7
leaq 0x5544(%rip), %rsi      # 0x1982a
movq %r15, %rdi
callq 0x45f0
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x14312
movq %rdx, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x30(%rbp)
jmp 0x14319
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x40(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0xa414
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1434a
callq 0x4310
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1435f
callq 0x4310
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x14388
callq 0x4310
jmp 0x14388
movq %rax, %r14
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x143c1
jmp 0x143c6
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x143b0
callq 0x4310
jmp 0x143b0
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
jne 0x143c1
jmp 0x143c6
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/server/server.cpp
// Function: NotFoundHandler::callback(Request*)
Response *callback(Request *req) {
    Response *res = new Response(404);
    if (!notFoundErrPage.empty()) {
      res->setHeader("Content-Type", "text/" + getExtension(notFoundErrPage));
      res->setBody(readFile(notFoundErrPage.c_str()));
    }
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movl $0x78, %edi
callq 0x4350
movq %rax, %rbx
movq %rax, %rdi
movl $0x194, %esi            # imm = 0x194
callq 0x82ca
cmpq $0x0, 0x10(%r14)
je 0x146e1
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4bbc(%rip), %rsi      # 0x19175
leaq 0x4bc1(%rip), %rdx      # 0x19181
leaq -0x88(%rbp), %rdi
callq 0x6f56
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7dfa
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xf5f2
leaq 0x51ee(%rip), %rcx      # 0x197ee
leaq -0xa8(%rbp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x43a0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1463a
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x14642
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0xa3f0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1467a
callq 0x4310
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1468f
callq 0x4310
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1469d
callq 0x4310
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x146ae
callq 0x4310
movq 0x8(%r14), %rsi
leaq -0xc8(%rbp), %r14
movq %r14, %rdi
callq 0xf119
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa414
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x146e1
callq 0x4310
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x14762
jmp 0x14767
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x14721
callq 0x4310
jmp 0x14721
movq %rax, %r14
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1473b
callq 0x4310
jmp 0x1473b
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1474e
callq 0x4310
jmp 0x1474e
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x14762
jmp 0x14767
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::parseTemplate()
void TemplateParser::parseTemplate() {
  string unparsedTemplate = readFile(filePath);
  int parsePointer = 0;
  while (parsePointer < (signed int) unparsedTemplate.size()) {
    int begin = findBeginOfCodeBlock(parsePointer, unparsedTemplate);
    int end = findEndOfCodeBlock(parsePointer, unparsedTemplate);
    if (begin < 0)
      break;
    appendHTMLToCode(parsePointer, begin, unparsedTemplate);
    appendCodeBlockToCode(begin, end, unparsedTemplate);
    parsePointer = end + endCodeBlockTag.size();
  }
  appendHTMLToCode(parsePointer, unparsedTemplate.size(), unparsedTemplate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x7dfa
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xf22c
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x1529d
callq 0x4310
movl -0x48(%rbp), %edx
testl %edx, %edx
jle 0x15319
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
movl %r13d, -0x2c(%rbp)
movq %r15, %rdi
leaq 0xabd7(%rip), %rsi      # 0x1fe90
leaq -0x2c(%rbp), %r14
movq %r14, %rdx
callq 0xf7c1
movl %eax, %r12d
movl %r13d, -0x2c(%rbp)
movq %r15, %rdi
leaq 0xabda(%rip), %rsi      # 0x1feb0
movq %r14, %rdx
callq 0xf7c1
testl %r12d, %r12d
js 0x1531e
movl %eax, %r14d
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x15b1e
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
movq %r15, %rcx
callq 0x163d6
addl 0xabac(%rip), %r14d     # 0x1feb8
movl -0x48(%rbp), %edx
movl %r14d, %r13d
cmpl %edx, %r14d
jl 0x152ab
jmp 0x15324
xorl %r14d, %r14d
jmp 0x15324
movl -0x48(%rbp), %edx
movl %r13d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x15b1e
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15341
callq 0x4310
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15362
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
jne 0x15372
jmp 0x15377
jmp 0x15362
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15377
callq 0x4310
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::TemplateUtils::writeMapToFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
int TemplateParser::TemplateUtils::writeMapToFile(
    std::string fname, std::map<std::string, std::string> *m) {
  int count = 0;
  if (m->empty())
    return 0;

  FILE *fp = fopen(fname.c_str(), "w");
  if (!fp)
    return -errno;

  for (std::map<std::string, std::string>::iterator it = m->begin();
       it != m->end(); it++) {
    fprintf(fp, "%s=%s\n", it->first.c_str(), it->second.c_str());
    count++;
  }

  fclose(fp);
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x28(%rsi)
je 0x15536
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x4612(%rip), %rsi      # 0x19af8
callq 0x43e0
testq %rax, %rax
je 0x1553b
movq %rax, %r14
movq 0x18(%rbx), %r12
addq $0x8, %rbx
cmpq %rbx, %r12
je 0x15548
leaq 0x45f3(%rip), %r13      # 0x19afa
xorl %r15d, %r15d
movq 0x20(%r12), %rdx
movq 0x40(%r12), %rcx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4490
incl %r15d
movq %r12, %rdi
callq 0x4270
movq %rax, %r12
cmpq %rbx, %rax
jne 0x1550a
jmp 0x1554b
xorl %r15d, %r15d
jmp 0x15553
callq 0x4060
xorl %r15d, %r15d
subl (%rax), %r15d
jmp 0x15553
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x4340
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::appendCodeBlockToCode(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void TemplateParser::appendCodeBlockToCode(int begin, int end,
                                           string &unparsedTemplate) {
  if (end <= begin || begin < 0)
    throw Server::Exception("Can not parse template " + filePath);
  int codeBlockSize = end - begin - beginCodeBlockTag.size();
  code +=
      unparsedTemplate.substr(begin + beginCodeBlockTag.size(), codeBlockSize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
testl %esi, %esi
js 0x16446
cmpl %esi, %edx
jle 0x16446
movq 0x9aa3(%rip), %rdi      # 0x1fe98
subl %edi, %edx
subl %esi, %edx
movl %esi, %eax
addq %rdi, %rax
movslq %edx, %r8
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
movq %rax, %rdx
movq %r8, %rcx
callq 0x4370
addq $0x28, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4130
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1643b
callq 0x4310
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x41f0
movq %rax, %rbx
addq $0x8, %r14
leaq 0x3457(%rip), %rsi      # 0x198b5
leaq -0x58(%rbp), %rdi
movq %r14, %rdx
callq 0xa7d7
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x138e0
xorl %r15d, %r15d
leaq 0x864d(%rip), %rsi      # 0x1ead0
leaq -0xe958(%rip), %rdx     # 0x7b32
movq %rbx, %rdi
callq 0x4570
movq %rax, %r14
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x164a7
callq 0x4310
testb %r15b, %r15b
jne 0x164b1
jmp 0x164d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
jmp 0x164d0
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x164d0
callq 0x4310
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::generateCode()
void TemplateParser::generateCode() {
  addReadFromTemplateToCode();
  addContextMapToCode();
  addIncludesToCode();
  addReturnToCode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x17272
movq %rbx, %rdi
callq 0x1751e
movq %rbx, %rdi
callq 0x1779c
addq $0x28, %rbx
leaq 0x354f(%rip), %rsi      # 0x19a50
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x45f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::TemplateUtils::runSystemCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TemplateParser::TemplateUtils::runSystemCommand(string command,
                                                     string error) {
  int ret = system(command.c_str());
#ifdef _WIN32
  if(ret != 0) {
      throw Server::Exception(error);
  }
#else
  if (WEXITSTATUS(ret) != EXIT_SUCCESS) {
    throw Server::Exception(error);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq (%rdi), %rdi
callq 0x42d0
testl $0xff00, %eax           # imm = 0xFF00
jne 0x17ab4
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x7dfa
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x138e0
xorl %r12d, %r12d
leaq 0x6fdb(%rip), %rsi      # 0x1ead0
leaq -0xffca(%rip), %rdx     # 0x7b32
movq %rbx, %rdi
callq 0x4570
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x17b15
callq 0x4310
testb %r12b, %r12b
jne 0x17b1f
jmp 0x17b27
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::~WholeGenome()
WholeGenome::~WholeGenome(){

    for(int j = 0; j < chrom_num; j++){
        ref_variant_by_chrid[j]->clear();
        delete ref_variant_by_chrid[j];
        que_variant_by_chrid[j]->clear();
        delete que_variant_by_chrid[j];
    }
    delete[] ref_variant_by_chrid;
    delete[] que_variant_by_chrid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x11e91
xorl %r15d, %r15d
movq 0x148(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rsi
callq 0x2b1a0
movq 0x148(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x11e41
movq %r14, %rdi
callq 0x284ec
movl $0x18, %esi
movq %r14, %rdi
callq 0x5340
movq 0x150(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rsi
callq 0x2b1a0
movq 0x150(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x11e79
movq %r14, %rdi
callq 0x284ec
movl $0x18, %esi
movq %r14, %rdi
callq 0x5340
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x11e16
movq 0x148(%rbx), %rdi
testq %rdi, %rdi
je 0x11ea2
callq 0x53f0
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
je 0x11eb3
callq 0x53f0
movq 0x270(%rbx), %rdi
testq %rdi, %rdi
je 0x11ece
movq 0x280(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x250(%rbx), %rdi
testq %rdi, %rdi
je 0x11ee9
movq 0x260(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x238(%rbx), %rdi
testq %rdi, %rdi
je 0x11f04
movq 0x248(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x220(%rbx), %rdi
testq %rdi, %rdi
je 0x11f1f
movq 0x230(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x208(%rbx), %rdi
testq %rdi, %rdi
je 0x11f3a
movq 0x218(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x1f0(%rbx), %rdi
testq %rdi, %rdi
je 0x11f55
movq 0x200(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq 0x1c0(%rbx), %rdi
leaq 0x1d0(%rbx), %rax
cmpq %rax, %rdi
je 0x11f73
movq (%rax), %rsi
incq %rsi
callq 0x5340
movq 0x1a0(%rbx), %rdi
leaq 0x1b0(%rbx), %rax
cmpq %rax, %rdi
je 0x11f91
movq (%rax), %rsi
incq %rsi
callq 0x5340
leaq 0x160(%rbx), %rdi
callq 0x28498
leaq 0x118(%rbx), %rdi
callq 0x29876
leaq 0xe8(%rbx), %rdi
callq 0x298ee
leaq 0xb8(%rbx), %rdi
callq 0x29876
leaq 0x88(%rbx), %rdi
callq 0x298ee
leaq 0x68(%rbx), %rdi
callq 0xe71c
leaq 0x50(%rbx), %rdi
callq 0xe71c
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x11ff7
movq (%rax), %rsi
incq %rsi
callq 0x5340
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x12014
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5340
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::CalculateEditDistance(DiploidVariant&, int, int)
int WholeGenome::CalculateEditDistance(DiploidVariant & dv,
                                int choice,
                                int match_mode){
    int score = 0;
    if(choice <= NOT_USE) return score;

    if(match_mode == 0){
        if(choice == -1){
            score += ScoreEditDistance(dv, 0);
        }else if(choice == -2){
            score += ScoreEditDistance(dv, 1);
        }else if(choice == 0){
            score += ScoreEditDistance(dv, 0);
            if(dv.multi_alts && !dv.zero_one_var){
                score += ScoreEditDistance(dv, 1);
            }
        }else{
            score += ScoreEditDistance(dv, 0);
            score += ScoreEditDistance(dv, 1);
        }
    }else{
        score += 2 * ScoreEditDistance(dv, choice);
    }

    return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
cmpl $-0x8, %edx
jl 0x16361
movl %edx, %eax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
testl %ecx, %ecx
je 0x1636c
movslq %eax, %rdx
shlq $0x5, %rdx
addq 0x28(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287e6
movl %eax, %ebp
addl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r15), %rdx
cmpl $-0x2, %eax
je 0x163d6
testl %eax, %eax
je 0x163a6
cmpl $-0x1, %eax
je 0x163da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287e6
movl %eax, %r12d
movq 0x28(%r15), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287e6
movl %eax, %ebp
addl %r12d, %ebp
jmp 0x16361
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287e6
movl %eax, %ebp
cmpb $0x1, 0x41(%r15)
jne 0x16361
cmpb $0x0, 0x42(%r15)
jne 0x16361
movq 0x28(%r15), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287e6
jmp 0x1635f
addq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x287e6
nop
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::PathNeedDecision(SequencePath&, std::multimap<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>**, int)
int WholeGenome::PathNeedDecision(SequencePath& sp, multimap<int, int> * choices_by_pos[], int pos){
    for(int i = 0; i < 2; i++){
        if(choices_by_pos[i]->find(pos) != choices_by_pos[i]->end()){
            pair<multimap<int, int>::iterator, multimap<int, int>::iterator> var_range;
            var_range = choices_by_pos[i]->equal_range(pos);

            for(auto it = var_range.first; it != var_range.second; ++it){
                int var_index = (*it).second;
                if(sp.choice_vector[var_index] <= MEANING_CHOICE_BOUND) return var_index;
            }
            // you need to make choices now
            // if(sp.choice_made[i].find(pos) == sp.choice_made[i].end()){
            //     // no choice made at current pos
            //     return true;
            // }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movl %ecx, (%r15)
movb $0x1, %bpl
xorl %eax, %eax
movq (%rbx,%rax,8), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x170b6
leaq 0x8(%rdi), %rsi
movl 0x4(%rsp), %ecx
movq %rsi, %rdx
xorl %r8d, %r8d
cmpl %ecx, 0x20(%rax)
setl %r8b
cmovgeq %rax, %rdx
movq 0x10(%rax,%r8,8), %rax
testq %rax, %rax
jne 0x17064
cmpq %rsi, %rdx
je 0x170b6
cmpl 0x20(%rdx), %ecx
jl 0x170b6
movq %r15, %rsi
callq 0x2dd60
cmpq %rdx, %rax
je 0x170b6
movq %rdx, %r12
movq 0x168(%r14), %r13
movslq 0x24(%rax), %rcx
cmpl $-0x9, (%r13,%rcx,4)
jl 0x170cb
movq %rax, %rdi
callq 0x5250
cmpq %r12, %rax
jne 0x1709d
movl $0x1, %eax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1704c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::CalculateScore(DiploidVariant&, int, int, int, int)
int WholeGenome::CalculateScore(DiploidVariant & dv,
                                int choice,
                                int score_unit,
                                int match_mode,
                                int score_scheme){
    int score = 0;
    if(choice <= NOT_USE) return score;
    if(score_unit == 0){
        score = 1;
    }else if(score_unit == 1){
        if(match_mode == 0){
            if(choice == -1){
                score += ScoreEditDistance(dv, 0);
            }else if(choice == -2){
                score += ScoreEditDistance(dv, 1);
            }else if(choice == 0){
                score += ScoreEditDistance(dv, 0);
                if(dv.multi_alts && !dv.zero_one_var){
                    score += ScoreEditDistance(dv, 1);
                }
            }else{
                score += ScoreEditDistance(dv, 0);
                score += ScoreEditDistance(dv, 1);
            }
        }else{
            score += ScoreEditDistance(dv, choice);
        }
    }

    if(score_scheme == 0){
        return score;
    }else if(score_scheme == 1 || score_scheme == 2){
        if(dv.flag == false && score_scheme == 1){
            return score;
        }else if(dv.flag && score_scheme == 2){
            return score;
        }else{
            return 0;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpl $-0x8, %edx
jl 0x175b4
movl %r9d, %ebx
movq %rsi, %r14
testl %ecx, %ecx
je 0x174f9
cmpl $0x1, %ecx
jne 0x17503
movq %rdi, %r15
leaq 0x8(%r14), %r12
testl %r8d, %r8d
je 0x1750a
movslq %edx, %rdx
shlq $0x5, %rdx
addq 0x28(%r14), %rdx
movq %r15, %rdi
movq %r12, %rsi
jmp 0x17589
movl $0x1, %ebp
jmp 0x17590
xorl %ebp, %ebp
jmp 0x17590
movq 0x28(%r14), %rax
cmpl $-0x2, %edx
je 0x1757c
testl %edx, %edx
je 0x17547
cmpl $-0x1, %edx
je 0x17580
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x287e6
movl %eax, %r13d
movq 0x28(%r14), %rdx
addq $0x20, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x287e6
movl %eax, %ebp
addl %r13d, %ebp
jmp 0x17590
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x287e6
movl %eax, %ebp
cmpb $0x1, 0x41(%r14)
jne 0x17590
cmpb $0x0, 0x42(%r14)
jne 0x17590
movq 0x28(%r14), %rdx
addq $0x20, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x287e6
addl %eax, %ebp
jmp 0x17590
addq $0x20, %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x287e6
movl %eax, %ebp
testl %ebx, %ebx
je 0x175b4
cmpl $0x1, %ebx
sete %cl
movb 0x4c(%r14), %al
testb %al, %al
sete %dl
testb %dl, %cl
jne 0x175b4
xorl %ecx, %ecx
testb %al, %al
cmovel %ecx, %ebp
cmpl $0x2, %ebx
cmovnel %ecx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/./diploidvariant.h
// Function: DiploidVariant::DiploidVariant(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool, bool, int, int, bool, double, bool)
DiploidVariant(int pos_ = -1,
        string ref_ = "",
        vector<string> alts_ = {"",""},
        bool heterozygous_ = false,
        bool multi_alts_ = false,
        int mdl_ = 0,
        int mil_ = 0,
        bool flag_ = false,
        double qual_ = 0.0,
        bool zero_one_var_ = false) :
        pos(pos_),
        ref(ref_),
        alts(alts_),
        heterozygous(heterozygous_),
        multi_alts(multi_alts_),
        mdl(mdl_),
        mil(mil_),
        flag(flag_),
        qual(qual_),
        zero_one_var(zero_one_var_){}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %r9d, %ebp
movl %r8d, %r14d
movq %rcx, %r12
movq %rdi, %rbx
movl %esi, (%rdi)
leaq 0x8(%rdi), %r15
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1123c
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x28582
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movl 0x48(%rsp), %edx
movl 0x40(%rsp), %esi
movb %r14b, 0x40(%rbx)
movb %bpl, 0x41(%rbx)
movb %al, 0x42(%rbx)
movl %esi, 0x44(%rbx)
movl %edx, 0x48(%rbx)
movb %cl, 0x4c(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x286a8
movq (%r13), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::EditDistance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline int WholeGenome::EditDistance(const std::string& s1, const std::string& s2)
{
	const std::size_t len1 = s1.size(), len2 = s2.size();
	std::vector<unsigned int> col(len2+1), prevCol(len2+1);

	for (unsigned int i = 0; i < prevCol.size(); i++)
		prevCol[i] = i;
	for (unsigned int i = 0; i < len1; i++) {
		col[0] = i+1;
		for (unsigned int j = 0; j < len2; j++)
                        // note that std::min({arg1, arg2, arg3}) works only in C++11,
                        // for C++98 use std::min(std::min(arg1, arg2), arg3)
			col[j+1] = std::min({ prevCol[1 + j] + 1, col[j] + 1, prevCol[j] + (s1[i]==s2[j] ? 0 : 1) });
		col.swap(prevCol);
	}
	return prevCol[len2];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rdx), %r12
leaq 0x1(%r12), %r15
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r15, %rsi
callq 0x29966
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x29966
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
je 0x28855
sarq $0x2, %rcx
xorl %edx, %edx
movl %edx, (%rdi,%rdx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rcx
ja 0x28848
cmpq $0x0, 0x20(%rsp)
je 0x28932
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
movq (%r14), %rcx
movq (%rbx), %rdx
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rbx
xorl %r9d, %r9d
movq %r13, %r10
movq %r15, 0x40(%rsp)
movq %r8, 0x50(%rsp)
movq %rbx, 0x48(%rsp)
leal 0x1(%r9), %ebx
movl %ebx, (%r13)
testq %r12, %r12
je 0x288e3
xorl %r14d, %r14d
movl %ebx, %ebp
leaq 0x1(%r14), %r15
movl %r15d, %r13d
movl (%rdi,%r13,4), %r11d
incl %r11d
incl %ebp
movb (%rcx,%r9), %sil
xorl %r8d, %r8d
cmpb (%rdx,%r14), %sil
setne %sil
cmpl %r11d, %ebp
jb 0x288c9
movl %r11d, %ebp
movb %sil, %r8b
addl (%rdi,%r14,4), %r8d
cmpl %ebp, %r8d
cmovbl %r8d, %ebp
movl %ebp, (%r10,%r13,4)
movq %r15, %r14
cmpq %r13, %r12
ja 0x288a2
movq %rdi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %r8
movq %r8, 0x18(%rsp)
movq %r10, 0x28(%rsp)
movq 0x40(%rsp), %r11
movq %r11, 0x30(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movl %ebx, %r9d
movq %rsi, %rbx
movq %rax, %r15
movq %rdi, %r13
movq %r10, %rdi
movq %r11, %rax
cmpq %r9, 0x20(%rsp)
ja 0x2887e
movq %r10, %rdi
jmp 0x28937
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
movl (%rdi,%r12,4), %ebx
callq 0x5340
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2895a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5340
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28985
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/./wholegenome.h
// Function: WholeGenome::merge(std::vector<Interval, std::allocator<Interval>>&)
vector<Interval> merge(vector<Interval> &intervals) {
        sort(intervals.begin(),intervals.end(),compInterval());
        vector<Interval> results;
        for(int i=0; i<intervals.size(); i++) {
            if(results.empty() || results.back().end < intervals[i].start)  // no overlap
                results.push_back(intervals[i]);
            else   // overlap
                results.back().end = max(results.back().end, intervals[i].end);
        }
        return results;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x28db8
movq %rdx, %r14
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x29a5d
movq %r15, %rdi
movq %r12, %rsi
callq 0x29b5a
movq (%r14), %rdx
movq 0x8(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
cmpq %rdx, %rax
je 0x28dc6
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0x28d6f
movl -0x4(%rsi), %eax
cmpl (%rdx,%r15), %eax
jge 0x28d85
addq %r15, %rdx
cmpq 0x10(%rbx), %rsi
je 0x28d94
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x28d9c
movl 0x4(%rdx,%r15), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, -0x4(%rsi)
jmp 0x28d9c
movq %rbx, %rdi
callq 0x29de0
incq %r12
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq $0x3, %rax
addq $0x8, %r15
cmpq %r12, %rax
ja 0x28d5d
jmp 0x28dc6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28dec
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/./diploidvariant.h
// Function: DiploidVariant::CompareNoGenotype(DiploidVariant const&)
bool CompareNoGenotype(const DiploidVariant & y){
        if(pos == y.pos && ref == y.ref){
            if(alts[0] == y.alts[0]) return true;
            if(multi_alts){
                if(alts[1] == y.alts[0]) return true;
                if(y.multi_alts && alts[1] == y.alts[1]){
                    return true;
                }
            }
            if(y.multi_alts && alts[0] == y.alts[1]){
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x29862
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdx
cmpq 0x10(%rsi), %rdx
jne 0x29862
testq %rdx, %rdx
je 0x297b7
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdi
callq 0x5350
testl %eax, %eax
jne 0x29862
movq 0x28(%r14), %r13
movq 0x28(%rbx), %r15
movq 0x8(%r13), %rdx
movq 0x8(%r15), %r12
cmpq %r12, %rdx
jne 0x297e8
movb $0x1, %bpl
testq %rdx, %rdx
je 0x29864
movq (%r15), %rsi
movq (%r13), %rdi
callq 0x5350
testl %eax, %eax
je 0x29864
cmpb $0x1, 0x41(%r14)
jne 0x29832
leaq 0x20(%r13), %rdi
cmpq %r12, 0x28(%r13)
jne 0x29819
movb $0x1, %bpl
testq %r12, %r12
je 0x29864
movq (%r15), %rsi
movq %rdi, %r13
movq (%rdi), %rdi
movq %r12, %rdx
callq 0x5350
movq %r13, %rdi
testl %eax, %eax
je 0x29864
cmpb $0x1, 0x41(%rbx)
jne 0x29832
addq $0x20, %r15
movq %r15, %rsi
callq 0x28eca
movb $0x1, %bpl
testb %al, %al
jne 0x29864
cmpb $0x1, 0x41(%rbx)
jne 0x29862
movq 0x28(%r14), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0x29862
movb $0x1, %bpl
testq %rdx, %rdx
je 0x29864
movq 0x20(%rcx), %rsi
movq (%rax), %rdi
callq 0x5350
testl %eax, %eax
je 0x29864
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/medvedevgroup[P]varmatch/src/util.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
	std::stringstream ss(s);
	std::string item;
	while (std::getline(ss, item, delim)) {
		if (!item.empty()) {
			elems.push_back(item);
		}
	}
	return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x54f0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2f2e6
cmpq $0x0, 0x10(%rsp)
je 0x2f2b6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10c62
jmp 0x2f2b6
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f2fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0xdc8c(%rip), %rsi      # 0x3cf90
leaq 0x28(%rsp), %rdi
callq 0x5280
leaq 0xa8(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f348
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0xdc41(%rip), %rsi      # 0x3cf90
leaq 0x28(%rsp), %rdi
callq 0x5280
leaq 0xa8(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: makeMaximal(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
vector<PII> makeMaximal(vector<PII> &maximal)
{
    sort(maximal.begin(), maximal.end(), bySecond);
    maximal.erase(unique(maximal.begin(), maximal.end()), maximal.end());
    vector<PII> ret;
    int maxi = -1;
    for (size_t i = 0; i < maximal.size(); ++ i) {
        if (maximal[i].first <= maxi) {
            continue;
        }
        ret.push_back(maximal[i]);
        maxi = maximal[i].second;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %r15
cmpq %r15, %r12
je 0x2871
movq %r15, %rax
subq %r12, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x52(%rip), %r13       # 0x27fc
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x80bd
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x81f4
movq (%r14), %r12
movq 0x8(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x85eb
movq 0x8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x8646
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
je 0x28f4
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
cmpl %edx, (%rax,%r15,8)
jle 0x28e2
leaq (%rax,%r15,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x28ce
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x28d6
movq %rbx, %rdi
callq 0x86a6
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl 0x4(%rax,%r15,8), %edx
incq %r15
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rsi, %r15
jb 0x28ad
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2918
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2330