LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x200f0
testb $0x1, %al
jne 0x1e02a
jmp 0x1e036
movl $0x0, -0x4(%rbp)
jmp 0x1e111
movq -0x48(%rbp), %rdi
callq 0x41f0
movq %rax, %rdi
leaq 0x3bfb(%rip), %rsi      # 0x21c44
callq 0x4490
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e06d
callq 0x4070
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e111
movq -0x18(%rbp), %rdi
callq 0x20110
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa3d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5f0
testb $0x1, %al
jne 0x1e09a
jmp 0x1e102
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rdi
callq 0x41f0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x41f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x3b68(%rip), %rsi      # 0x21c46
movb $0x0, %al
callq 0x4580
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd6f0
movq %rax, -0x40(%rbp)
jmp 0x1e07a
movq -0x28(%rbp), %rdi
callq 0x43f0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x1ea93
cmpl $0x0, -0xc(%rbp)
jge 0x1eb27
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x4250
movq -0x78(%rbp), %rdx
movq %rax, -0x80(%rbp)
addq $0x8, %rdx
leaq 0x2f4d(%rip), %rsi      # 0x21a01
leaq -0x38(%rbp), %rdi
callq 0xd3b0
jmp 0x1eabf
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b360
jmp 0x1eace
movq -0x80(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0xdfeb(%rip), %rsi      # 0x2cac8
leaq -0x150d4(%rip), %rdx    # 0x9a10
callq 0x4680
jmp 0x1ebe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1eb11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4768
testb $0x1, -0x45(%rbp)
jne 0x1eb19
jmp 0x1eb22
movq -0x80(%rbp), %rdi
callq 0x4310
jmp 0x1ebda
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x9c(%rbp)
leaq 0xf3f4(%rip), %rdi      # 0x2df30
movq %rdi, -0xa8(%rbp)
callq 0x4300
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl -0x9c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x4300
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rsi
addq %rax, %rdx
movslq -0x4c(%rbp), %rcx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4410
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
addq $0x28, %rdi
callq 0x44e0
jmp 0x1ebb3
leaq -0x70(%rbp), %rdi
callq 0x4768
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4768
movq -0x40(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::generateCode()
void TemplateParser::generateCode() {
  addReadFromTemplateToCode();
  addContextMapToCode();
  addIncludesToCode();
  addReturnToCode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1f400
movq -0x10(%rbp), %rdi
callq 0x1f5c0
movq -0x10(%rbp), %rdi
callq 0x1f7a0
movq -0x10(%rbp), %rdi
callq 0x1f9c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::makeLocalTemplate()
void TemplateParser::makeLocalTemplate() {
  string templateContent = readFile(filePath);
  if (writeToFile(templateContent,
                  outputFolder + "/" + localTemplate(parserNum)) < 0)
    throw Server::Exception("Can not write template to local " + outputFolder +
                            "folder");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x110(%rbp)
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x4200
movq -0x108(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x152d0
jmp 0x1f1e0
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq 0xee40(%rip), %rsi      # 0x2e030
leaq 0x1e24(%rip), %rdx      # 0x2101b
leaq -0x98(%rbp), %rdi
callq 0xd650
jmp 0x1f205
movq -0x110(%rbp), %rax
movl (%rax), %esi
leaq -0xb8(%rbp), %rdi
callq 0x1db10
jmp 0x1f21c
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0xd360
jmp 0x1f235
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x15d00
movl %eax, -0x114(%rbp)
jmp 0x1f24a
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0xb8(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
movl -0x114(%rbp), %eax
cmpl $0x0, %eax
jge 0x1f3d4
movb $0x1, -0xf9(%rbp)
movl $0x28, %edi
callq 0x4250
movq %rax, -0x120(%rbp)
leaq 0x2780(%rip), %rsi      # 0x21a19
leaq 0xed90(%rip), %rdx      # 0x2e030
leaq -0xf8(%rbp), %rdi
callq 0xd3b0
jmp 0x1f2ae
leaq 0x2785(%rip), %rdx      # 0x21a3a
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0xd310
jmp 0x1f2ca
movq -0x120(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1b360
jmp 0x1f2df
movq -0x120(%rbp), %rdi
movb $0x0, -0xf9(%rbp)
leaq 0xd7d4(%rip), %rsi      # 0x2cac8
leaq -0x158eb(%rip), %rdx    # 0x9a10
callq 0x4680
jmp 0x1f3f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4768
jmp 0x1f3ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f3e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f36d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0xb8(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
jmp 0x1f3e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f3bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f3af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4768
leaq -0xf8(%rbp), %rdi
callq 0x4768
testb $0x1, -0xf9(%rbp)
jne 0x1f3c6
jmp 0x1f3d2
movq -0x120(%rbp), %rdi
callq 0x4310
jmp 0x1f3e6
leaq -0x28(%rbp), %rdi
callq 0x4768
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4768
movq -0x50(%rbp), %rdi
callq 0x46b0
nopl (%rax,%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::addContextMapToCode()
void TemplateParser::addContextMapToCode() {
  string mapCode = "std::map<std::string, std::string> context;\n";
  // `mapFile` should be changed if we want to handle requests
  //  in a multi-thread non-blocking way
  mapCode +=
      "readMapFromFile(\"" + outputFolder + "/" + mapFile + "\", &context);\n";
  code = mapCode + code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x46c0
movq -0xe8(%rbp), %rdx
leaq 0x25b1(%rip), %rsi      # 0x21ba9
leaq -0x28(%rbp), %rdi
callq 0x4550
jmp 0x1f603
leaq -0x29(%rbp), %rdi
callq 0x4440
leaq 0x25c3(%rip), %rsi      # 0x21bd6
leaq 0xea16(%rip), %rdx      # 0x2e030
leaq -0xc0(%rbp), %rdi
callq 0xd3b0
jmp 0x1f628
leaq 0x19ec(%rip), %rdx      # 0x2101b
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xd310
jmp 0x1f644
leaq 0xea05(%rip), %rdx      # 0x2e050
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd360
jmp 0x1f65d
leaq 0x2584(%rip), %rdx      # 0x21be8
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd310
jmp 0x1f673
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x44e0
jmp 0x1f682
leaq -0x60(%rbp), %rdi
callq 0x4768
leaq -0x80(%rbp), %rdi
callq 0x4768
leaq -0xa0(%rbp), %rdi
callq 0x4768
leaq -0xc0(%rbp), %rdi
callq 0x4768
movq -0xf0(%rbp), %rdx
addq $0x28, %rdx
leaq -0xe0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd730
jmp 0x1f6c9
movq -0xf0(%rbp), %rdi
addq $0x28, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x44b0
leaq -0xe0(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4440
jmp 0x1f78c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f783
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f76b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4768
leaq -0x80(%rbp), %rdi
callq 0x4768
leaq -0xa0(%rbp), %rdi
callq 0x4768
leaq -0xc0(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
movq -0x38(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::addIncludesToCode()
void TemplateParser::addIncludesToCode() {
  string include = "#include <iostream>\n";
  include += "#include <string>\n";
  include += "#include <map>\n";
  include += "#include <cstring>\n";
  include += "#include \"" + utilitiesHeaderPath + "\"\n";
  include += "using namespace std;\n";
  code = include + "int main(int argc, char const *argv[])\n{\n" + code + "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x46c0
movq -0xe8(%rbp), %rdx
leaq 0x22fc(%rip), %rsi      # 0x21ad4
leaq -0x28(%rbp), %rdi
callq 0x4550
jmp 0x1f7e3
leaq -0x29(%rbp), %rdi
callq 0x4440
leaq 0x22f6(%rip), %rsi      # 0x21ae9
leaq -0x28(%rbp), %rdi
callq 0x43c0
jmp 0x1f7fe
leaq 0x22f7(%rip), %rsi      # 0x21afc
leaq -0x28(%rbp), %rdi
callq 0x43c0
jmp 0x1f810
leaq 0x22f5(%rip), %rsi      # 0x21b0c
leaq -0x28(%rbp), %rdi
callq 0x43c0
jmp 0x1f822
leaq 0x22f7(%rip), %rsi      # 0x21b20
leaq 0xe740(%rip), %rdx      # 0x2df70
leaq -0x80(%rbp), %rdi
callq 0xd3b0
jmp 0x1f83b
leaq 0x22e9(%rip), %rdx      # 0x21b2b
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd310
jmp 0x1f851
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x44e0
jmp 0x1f860
leaq -0x60(%rbp), %rdi
callq 0x4768
leaq -0x80(%rbp), %rdi
callq 0x4768
leaq 0x22b5(%rip), %rsi      # 0x21b2e
leaq -0x28(%rbp), %rdi
callq 0x43c0
jmp 0x1f884
leaq 0x22b9(%rip), %rdx      # 0x21b44
leaq -0xe0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd650
jmp 0x1f89d
movq -0xf0(%rbp), %rdx
addq $0x28, %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xd360
jmp 0x1f8bd
leaq 0x1efc(%rip), %rdx      # 0x217c0
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xd310
jmp 0x1f8d9
movq -0xf0(%rbp), %rdi
addq $0x28, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x44b0
leaq -0xa0(%rbp), %rdi
callq 0x4768
leaq -0xc0(%rbp), %rdi
callq 0x4768
leaq -0xe0(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4440
jmp 0x1f9b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f9ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f96e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4768
leaq -0x80(%rbp), %rdi
callq 0x4768
jmp 0x1f9ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1f99f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4768
leaq -0xe0(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
movq -0x38(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: mkdirNoErrors(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string mkdirNoErrors(const std::string& dirName) {
//do not error if dir already exists (-p flag on linux)
#ifdef _WIN32
  return ("(if not exist \"" + dirName + "\" " + SysCmd::mkdir + "\"" + dirName + "\")");
#else
  return (SysCmd::mkdir + "-p \"" + dirName + "\"");
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe4bb(%rip), %rsi      # 0x2ded0
leaq 0x2231(%rip), %rdx      # 0x21c4d
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xd650
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xd360
jmp 0x1fa3c
movq -0x78(%rbp), %rdi
leaq 0x1f2d(%rip), %rdx      # 0x21974
leaq -0x30(%rbp), %rsi
callq 0xd310
jmp 0x1fa52
leaq -0x30(%rbp), %rdi
callq 0x4768
leaq -0x50(%rbp), %rdi
callq 0x4768
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1fa94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4768
leaq -0x50(%rbp), %rdi
callq 0x4768
movq -0x58(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x41f0
movq %rax, %rdi
callq 0x4340
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x1fb6b
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x4250
movq -0x50(%rbp), %rsi
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4200
jmp 0x1fb09
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b360
jmp 0x1fb18
movq -0x58(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0xcfa1(%rip), %rsi      # 0x2cac8
leaq -0x1611e(%rip), %rdx    # 0x9a10
callq 0x4680
jmp 0x1fb7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fb58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4768
testb $0x1, -0x45(%rbp)
jne 0x1fb60
jmp 0x1fb69
movq -0x58(%rbp), %rdi
callq 0x4310
jmp 0x1fb71
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46b0
nopw (%rax,%rax)
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::deleteExecutable()
void TemplateParser::deleteExecutable() {
  string cmd = SysCmd::rm + outputFolder + SysCmd::slash + programName;
  string error = "Error in deleting executable file at  " + outputFolder + "/" +
                 programName;
  TemplateUtils::runSystemCommand(cmd, error);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq 0xe26f(%rip), %rsi      # 0x2de90
leaq 0xe408(%rip), %rdx      # 0x2e030
leaq -0x68(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xd730
movq -0x120(%rbp), %rsi
leaq 0xe2aa(%rip), %rdx      # 0x2def0
leaq -0x48(%rbp), %rdi
callq 0xd360
jmp 0x1fc51
movq -0x128(%rbp), %rdx
addq $0xa0, %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd360
jmp 0x1fc6e
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x68(%rbp), %rdi
callq 0x4768
leaq 0x1f70(%rip), %rsi      # 0x21bf7
leaq 0xe3a2(%rip), %rdx      # 0x2e030
leaq -0xd8(%rbp), %rdi
callq 0xd3b0
jmp 0x1fc9c
leaq 0x1378(%rip), %rdx      # 0x2101b
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xd310
jmp 0x1fcb8
movq -0x128(%rbp), %rdx
addq $0xa0, %rdx
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xd360
jmp 0x1fcdb
leaq -0xb8(%rbp), %rdi
callq 0x4768
leaq -0xd8(%rbp), %rdi
callq 0x4768
leaq -0xf8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4200
jmp 0x1fd05
leaq -0x118(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4200
jmp 0x1fd1a
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x1fab0
jmp 0x1fd2f
leaq -0x118(%rbp), %rdi
callq 0x4768
leaq -0xf8(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1fd88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x68(%rbp), %rdi
callq 0x4768
jmp 0x1fe30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1fe27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1fdcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4768
leaq -0xd8(%rbp), %rdi
callq 0x4768
jmp 0x1fe27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1fe1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1fe0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x4768
leaq -0xf8(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
leaq -0x28(%rbp), %rdi
callq 0x4768
movq -0x70(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: medvedevgroup[P]varmatch/src/vm.cpp
// Function: usage(char*)
int usage(char* command) {
	cout << "\n";
	cout << "\tPlease cite our paper if you are using this program in your research." << endl;
    cout << endl;
	cout << "Usage: " << endl;
    cout << command << " -g genome file path(FASTA format)" << endl;
    cout << "\t-r reference VCF file path" << endl;
    cout << "\t-q query VCF file path" << endl;
    cout << "\t-o output file prefix" << endl;
    cout << "\t[-t thread number]" << endl;
    cout << "\t[-n normalize VCF entries before comparing]" << endl;
    cout << "\t[-m single VCF file to remove duplicates]" << endl;
    cout << "\t[-G do not match genotype when match vcf records]" << endl;
    cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6b715(%rip), %rdi     # 0x73fb8
leaq 0x4b7e2(%rip), %rsi     # 0x5408c
callq 0x6420
movq 0x6b702(%rip), %rdi     # 0x73fb8
leaq 0x4c009(%rip), %rsi     # 0x548c6
callq 0x6420
movq %rax, %rdi
movq 0x6b6b4(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b6e0(%rip), %rdi     # 0x73fb8
movq 0x6b6a1(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b6cd(%rip), %rdi     # 0x73fb8
leaq 0x4c01b(%rip), %rsi     # 0x5490d
callq 0x6420
movq %rax, %rdi
movq 0x6b67f(%rip), %rsi     # 0x73f80
callq 0x6480
movq -0x8(%rbp), %rsi
movq 0x6b6a7(%rip), %rdi     # 0x73fb8
callq 0x6420
movq %rax, %rdi
leaq 0x4bff5(%rip), %rsi     # 0x54915
callq 0x6420
movq %rax, %rdi
movq 0x6b651(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b67d(%rip), %rdi     # 0x73fb8
leaq 0x4bff6(%rip), %rsi     # 0x54938
callq 0x6420
movq %rax, %rdi
movq 0x6b62f(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b65b(%rip), %rdi     # 0x73fb8
leaq 0x4bff0(%rip), %rsi     # 0x54954
callq 0x6420
movq %rax, %rdi
movq 0x6b60d(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b639(%rip), %rdi     # 0x73fb8
leaq 0x4bfe6(%rip), %rsi     # 0x5496c
callq 0x6420
movq %rax, %rdi
movq 0x6b5eb(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b617(%rip), %rdi     # 0x73fb8
leaq 0x4bfdb(%rip), %rsi     # 0x54983
callq 0x6420
movq %rax, %rdi
movq 0x6b5c9(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b5f5(%rip), %rdi     # 0x73fb8
leaq 0x4bfcd(%rip), %rsi     # 0x54997
callq 0x6420
movq %rax, %rdi
movq 0x6b5a7(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b5d3(%rip), %rdi     # 0x73fb8
leaq 0x4bfd8(%rip), %rsi     # 0x549c4
callq 0x6420
movq %rax, %rdi
movq 0x6b585(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b5b1(%rip), %rdi     # 0x73fb8
leaq 0x4bfe1(%rip), %rsi     # 0x549ef
callq 0x6420
movq %rax, %rdi
movq 0x6b563(%rip), %rsi     # 0x73f80
callq 0x6480
movq 0x6b58f(%rip), %rdi     # 0x73fb8
movq 0x6b550(%rip), %rsi     # 0x73f80
callq 0x6480
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1b612
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32660
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1b5b6
movq -0x20(%rbp), %rdi
callq 0x32680
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x6440
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32660
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b602
movq -0x28(%rbp), %rdi
callq 0x32680
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x6440
jmp 0x1b604
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b55b
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1b630
movq -0x30(%rbp), %rdi
callq 0x6570
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1b64e
movq -0x38(%rbp), %rdi
callq 0x6570
movq -0x18(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x32500
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x32560
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0xbca0
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0xbca0
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0xbca0
movq -0x18(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0xbca0
movq -0x18(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x6828
movq -0x18(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x6828
movq -0x18(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x325c0
movq -0x18(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x32620
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
callq 0x32640
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
callq 0x32620
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x32640
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x13370
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x13370
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x6828
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x6828
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $-0x9, -0x1c(%rbp)
jg 0x20af6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20bda
cmpl $0x0, -0x20(%rbp)
jne 0x20bbc
cmpl $-0x1, -0x1c(%rbp)
jne 0x20b20
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x1d690
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x20bba
cmpl $-0x2, -0x1c(%rbp)
jne 0x20b40
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1d690
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x20bb8
cmpl $0x0, -0x1c(%rbp)
jne 0x20b89
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x1d690
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x20b87
movq -0x18(%rbp), %rax
testb $0x1, 0x42(%rax)
jne 0x20b87
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1d690
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x20bb6
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x1d690
movq -0x30(%rbp), %rdi
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1d690
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x20bb8
jmp 0x20bba
jmp 0x20bd4
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1d690
shll %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jge 0x218ad
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x24(%rbp), %rsi
callq 0x34900
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x34930
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x33ac0
testb $0x1, %al
jne 0x2180c
jmp 0x2189d
leaq -0x48(%rbp), %rdi
callq 0x34960
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x24(%rbp), %rsi
callq 0x34990
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x349d0
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x33ac0
testb $0x1, %al
jne 0x2185e
jmp 0x2189b
leaq -0x60(%rbp), %rdi
callq 0x34a00
movl 0x4(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
addq $0x168, %rdi            # imm = 0x168
movslq -0x64(%rbp), %rsi
callq 0x19a60
cmpl $-0xa, (%rax)
jg 0x2188e
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x218b4
jmp 0x21890
leaq -0x60(%rbp), %rdi
callq 0x34a20
jmp 0x21847
jmp 0x2189d
jmp 0x2189f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x217be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: GetMatchmodeFromModeIndex(int)
int GetMatchmodeFromModeIndex(int mode_index){
    int result = mode_index;
    result >>= 2;
    result &= 1;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl %r9d, -0x6c(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x6c(%rbp), %ecx
movq %r8, -0x50(%rbp)
movq %rdx, -0x68(%rbp)
movl %esi, %r9d
movq -0x68(%rbp), %rsi
movq %rdi, %r10
movb %cl, %dl
movb %al, %dil
movb 0x28(%rbp), %al
movb 0x20(%rbp), %cl
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r11d
movq %r10, -0x8(%rbp)
movl %r9d, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %r8, -0x20(%rbp)
andb $0x1, %dil
movb %dil, -0x21(%rbp)
andb $0x1, %dl
movb %dl, -0x22(%rbp)
andb $0x1, %cl
movb %cl, -0x23(%rbp)
movsd %xmm0, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x61b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x28, %rdi
callq 0x32950
jmp 0x32b55
movq -0x58(%rbp), %rax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
movb -0x22(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x41(%rax)
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x42(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x44(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x48(%rax)
movb -0x23(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x4c(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x6828
movq -0x40(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::initialize_score_matrix(int**, char**, int, int)
inline void WholeGenome::initialize_score_matrix(int **score, char **trackBack, int M, int N)
{
    for (int i = 0; i < M+1; i++)
    {
        score[0][i] = i * -1;
        trackBack[0][i] = '-';
    }

    for (int i = 0; i < N+1; i++)
    {
        score[i][0] = i * -1;
        trackBack[i][0] = '|';
    }

    trackBack[0][0] = '*';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x33467
imull $-0x1, -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x2d, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3342e
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x334a7
imull $-0x1, -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x7c, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3346e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0x2a, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38820
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38850
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x387e0
movq -0x48(%rbp), %rdi
movb $0x0, -0x2a(%rbp)
callq 0x33dc0
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x344d0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x344a4
movq -0x48(%rbp), %rdi
callq 0x38880
testb $0x1, %al
jne 0x3441e
movq -0x48(%rbp), %rdi
callq 0x388c0
movl 0x4(%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x34520
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x34452
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x34520
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x38900
jmp 0x34439
jmp 0x34494
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x345a0
jmp 0x344c1
movq -0x48(%rbp), %rdi
callq 0x388c0
addq $0x4, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x34520
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0x32a80
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x60(%rbp)
callq 0x388c0
movl -0x60(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x34496
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x343ca
movb $0x1, -0x2a(%rbp)
testb $0x1, -0x2a(%rbp)
jne 0x344b7
movq -0x48(%rbp), %rdi
callq 0x345a0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: medvedevgroup[P]varmatch/src/wholegenome.cpp
// Function: WholeGenome::GetIndexFromMatchScore(int, int, int)
inline int WholeGenome::GetIndexFromMatchScore(int score_unit, int match_mode, int score_scheme){
    int result = 0;
    result |= score_unit & 1;
    result <<= 1;
    result |= match_mode & 1;
    result <<= 2;
    result |= score_scheme & 3;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x3670c
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xdcb0
testb $0x1, %al
jne 0x365e4
jmp 0x3670c
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9080
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x386e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xdcb0
testb $0x1, %al
jne 0x3661c
jmp 0x36625
movb $0x1, -0x1(%rbp)
jmp 0x36710
movq -0x20(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x366c1
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x9080
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x386e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xdcb0
testb $0x1, %al
jne 0x3666c
jmp 0x36675
movb $0x1, -0x1(%rbp)
jmp 0x36710
movq -0x18(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x366bf
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x9080
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x386e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xdcb0
testb $0x1, %al
jne 0x366b9
jmp 0x366bf
movb $0x1, -0x1(%rbp)
jmp 0x36710
jmp 0x366c1
movq -0x18(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x3670a
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9080
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x386e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xdcb0
testb $0x1, %al
jne 0x36704
jmp 0x3670a
movb $0x1, -0x1(%rbp)
jmp 0x36710
jmp 0x3670c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x53ef0
movq -0x1d8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x6680
leaq -0x1c0(%rbp), %rdi
callq 0x65e0
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x67c0
movq %rax, -0x1e0(%rbp)
jmp 0x53da4
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6550
movb %al, -0x1e1(%rbp)
jmp 0x53dc2
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x53dce
jmp 0x53e23
leaq -0x1c0(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0x53e1e
movq -0x18(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x17750
jmp 0x53df0
jmp 0x53e1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x6828
leaq -0x1a0(%rbp), %rdi
callq 0x6360
jmp 0x53e56
jmp 0x53d84
movq -0x18(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x6828
leaq -0x1a0(%rbp), %rdi
callq 0x6360
movq -0x1f0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0xaa(%rip), %rdx       # 0x3880
callq 0x7ee0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f30
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8020
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8060
movq -0x10(%rbp), %rdi
callq 0x7f60
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8060
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x7f90
movq -0x80(%rbp), %rdi
movq %rax, -0x58(%rbp)
movb $0x0, -0x59(%rbp)
callq 0x80a0
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80c0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x3a4c
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x80e0
movl (%rax), %eax
cmpl -0x60(%rbp), %eax
jg 0x39f9
jmp 0x3a27
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x80e0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8100
jmp 0x3a14
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x80e0
movl 0x4(%rax), %eax
movl %eax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x39c0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x8170
jmp 0x3a6f
movb $0x1, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3a5f
movq -0x80(%rbp), %rdi
callq 0x8170
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: writeBinary(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void writeBinary(FILE* out, const string &s)
{
	int n = s.size();
	fwrite(&n, sizeof(n), 1, out);
	if (n > 0) {
		fwrite(&s[0], sizeof(s[0]), n, out);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpl $0x0, -0x14(%rbp)
jle 0x3b7b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32e0
movq %rax, %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x3460
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: readBinary(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readBinary(FILE* in, string &s)
{
	int n;
	fread(&n, sizeof(n), 1, in);
	s.resize(n);
	if (n > 0) {
		fread(&s[0], sizeof(s[0]), n, in);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x33a0
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3360
cmpl $0x0, -0x14(%rbp)
jle 0x3bec
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3490
movq %rax, %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: getLine(_IO_FILE*)
bool getLine(FILE* in)
{
	bool ret = fgets(line, maxlength, in);
	int len = strlen(line);
	while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
		line[len - 1] = 0;
		-- len;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x25689(%rip), %rdi     # 0x292a0
movl $0x5f5e100, %esi        # imm = 0x5F5E100
callq 0x33d0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq 0x2566c(%rip), %rdi     # 0x292a0
callq 0x3100
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jle 0x3c88
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x25649(%rip), %rax     # 0x292a0
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x12(%rbp)
je 0x3c82
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x2562b(%rip), %rax     # 0x292a0
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3c91
jmp 0x3cb0
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x255ff(%rip), %rax     # 0x292a0
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3c3c
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)