LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getBody[abi:cxx11]()
string Request::getBody() {
  string bs = "";
  for (auto it = body.begin(); !body.empty() && it != body.end(); it++)
    bs += it->first + "=" + it->second + "&";
  return bs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x46c0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x10c4d(%rip), %rsi     # 0x21595
callq 0x4550
jmp 0x1094f
leaq -0x12(%rbp), %rdi
callq 0x4440
movq -0xb8(%rbp), %rdi
addq $0x88, %rdi
callq 0xd5a0
movq %rax, -0x30(%rbp)
movq -0xb8(%rbp), %rdi
addq $0x88, %rdi
callq 0xd5d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
jne 0x109bb
movq -0xb8(%rbp), %rdi
addq $0x88, %rdi
callq 0xd620
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5f0
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x109ca
jmp 0x10ada
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rsi
leaq 0x10a76(%rip), %rdx     # 0x21453
leaq -0x98(%rbp), %rdi
callq 0xd650
jmp 0x109eb
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xd360
jmp 0x10a0d
leaq 0x10b36(%rip), %rdx     # 0x2154a
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd310
jmp 0x10a23
movq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x44e0
jmp 0x10a35
leaq -0x58(%rbp), %rdi
callq 0x4768
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd6f0
movq %rax, -0xa0(%rbp)
jmp 0x1096f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4440
jmp 0x10b0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10b00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10acc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10ac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4768
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
jmp 0x10b00
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x10af0
movq -0xb0(%rbp), %rdi
callq 0x4768
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x4768
movq -0x20(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getHeaders[abi:cxx11]()
cimap Request::getHeaders() {
  vector<string> res;
  for (map<string, string>::iterator i = headers.begin();
       !headers.empty() && i != headers.end(); i++) {
    res.push_back(i->first);
    res.push_back(i->second);
  }
  return headers;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x13700
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0xd5a0
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0xd5d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x12a57
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0xd620
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5f0
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x12a60
jmp 0x12abf
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x13720
jmp 0x12a77
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x13720
jmp 0x12a92
jmp 0x12a94
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd6f0
movq %rax, -0x50(%rbp)
jmp 0x12a1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x13680
jmp 0x12ae5
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x28, %rsi
callq 0x13790
jmp 0x12ad2
leaq -0x28(%rbp), %rdi
callq 0x13680
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46b0
nop
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getQueryString[abi:cxx11]()
string Request::getQueryString() {
  if (query.empty())
    return "";
  string res = "?";
  for (map<string, string>::iterator i = query.begin();
       !query.empty() && i != query.end(); i++) {
    res += i->first;
    res += "=";
    res += i->second;
    res += "&";
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x58, %rdi
callq 0xd5d0
testb $0x1, %al
jne 0x12b22
jmp 0x12b6d
leaq -0x11(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x46c0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xea57(%rip), %rsi      # 0x21595
callq 0x4550
jmp 0x12b45
leaq -0x11(%rbp), %rdi
callq 0x4440
jmp 0x12ca3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4440
jmp 0x12cad
movb $0x0, -0x25(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x46c0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xea19(%rip), %rsi      # 0x215a6
callq 0x4550
jmp 0x12b94
leaq -0x26(%rbp), %rdi
callq 0x4440
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0xd5a0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0xd5d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x12be8
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0xd620
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5f0
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x12bf4
jmp 0x12c8e
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x44e0
jmp 0x12c0b
movq -0x58(%rbp), %rdi
leaq 0xe83d(%rip), %rsi      # 0x21453
callq 0x43c0
jmp 0x12c1d
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x44e0
jmp 0x12c38
movq -0x58(%rbp), %rdi
leaq 0xe907(%rip), %rsi      # 0x2154a
callq 0x43c0
jmp 0x12c4a
jmp 0x12c4c
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd6f0
movq %rax, -0x40(%rbp)
jmp 0x12bae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x4440
jmp 0x12cad
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4768
jmp 0x12cad
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x12ca1
movq -0x58(%rbp), %rdi
callq 0x4768
jmp 0x12ca3
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getHeadersString[abi:cxx11]()
string Request::getHeadersString() {
  string headerString = "";
  for (auto it = headers.begin(); !headers.empty() && it != headers.end(); it++)
    headerString += it->first + "=" + it->second + "&";
  return headerString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x46c0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0xe87d(%rip), %rsi      # 0x21595
callq 0x4550
jmp 0x12d1f
leaq -0x12(%rbp), %rdi
callq 0x4440
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0xd5a0
movq %rax, -0x30(%rbp)
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0xd5d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
jne 0x12d82
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0xd620
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5f0
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x12d91
jmp 0x12ea1
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rsi
leaq 0xe6af(%rip), %rdx      # 0x21453
leaq -0x98(%rbp), %rdi
callq 0xd650
jmp 0x12db2
leaq -0x30(%rbp), %rdi
callq 0xd6d0
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xd360
jmp 0x12dd4
leaq 0xe76f(%rip), %rdx      # 0x2154a
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd310
jmp 0x12dea
movq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x44e0
jmp 0x12dfc
leaq -0x58(%rbp), %rdi
callq 0x4768
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd6f0
movq %rax, -0xa0(%rbp)
jmp 0x12d3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4440
jmp 0x12ed3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x12ec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x12e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x12e8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4768
leaq -0x78(%rbp), %rdi
callq 0x4768
leaq -0x98(%rbp), %rdi
callq 0x4768
jmp 0x12ec7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12eb7
movq -0xb0(%rbp), %rdi
callq 0x4768
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x4768
movq -0x20(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::serializeToFile(Request*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Request::serializeToFile(Request *req, string filePath) {
  string reqString = to_string(req->getMethod());
  reqString += "\n";
  reqString += req->getPath();
  reqString += "\n";
  reqString += req->getHeadersString();
  reqString += "\n";
  reqString += req->getBody();
  reqString += "\n";
  reqString += req->getQueryString();
  writeToFile(reqString, filePath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x106c0
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x98c0
movq -0xc8(%rbp), %rdi
leaq 0xe69d(%rip), %rsi      # 0x217c0
callq 0x43c0
jmp 0x1312a
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x10670
jmp 0x13139
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x44e0
jmp 0x13148
leaq -0x60(%rbp), %rdi
callq 0x4768
leaq 0xe668(%rip), %rsi      # 0x217c0
leaq -0x30(%rbp), %rdi
callq 0x43c0
jmp 0x13163
movq -0x8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x12cc0
jmp 0x13172
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x44e0
jmp 0x13181
leaq -0x80(%rbp), %rdi
callq 0x4768
leaq 0xe62f(%rip), %rsi      # 0x217c0
leaq -0x30(%rbp), %rdi
callq 0x43c0
jmp 0x1319c
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x108f0
jmp 0x131ae
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x44e0
jmp 0x131c0
leaq -0xa0(%rbp), %rdi
callq 0x4768
leaq 0xe5ed(%rip), %rsi      # 0x217c0
leaq -0x30(%rbp), %rdi
callq 0x43c0
jmp 0x131de
movq -0x8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x12af0
jmp 0x131f0
leaq -0x30(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x44e0
jmp 0x13202
leaq -0xc0(%rbp), %rdi
callq 0x4768
movq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x15d00
jmp 0x13220
leaq -0x30(%rbp), %rdi
callq 0x4768
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x132a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4768
jmp 0x132a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4768
jmp 0x132a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4768
jmp 0x132a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4768
leaq -0x30(%rbp), %rdi
callq 0x4768
movq -0x38(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: readFile[abi:cxx11](char const*)
string readFile(const char *filename) {
  ifstream infile;
  infile.open(filename, infile.binary);
  if (!infile.is_open()) return string();

  infile.seekg(0, infile.end);
  size_t length = infile.tellg();
  infile.seekg(0, infile.beg);

  if (length > BUFFER_SIZE)
    length = BUFFER_SIZE;
  char* buffer = new char[length + 1];

  infile.read(buffer, length);

  string s(buffer, length);
  delete[] buffer;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x4480
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x42d0
jmp 0x1508e
leaq -0x218(%rbp), %rdi
callq 0x4610
movb %al, -0x269(%rbp)
jmp 0x150a2
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x150e0
jmp 0x150ae
movq -0x268(%rbp), %rdi
callq 0x4560
movl $0x1, -0x228(%rbp)
jmp 0x1528d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x152a9
xorl %eax, %eax
movl %eax, %esi
leaq -0x218(%rbp), %rdi
movl $0x2, %edx
callq 0x4530
jmp 0x150f7
leaq -0x218(%rbp), %rdi
callq 0x46a0
movq %rdx, -0x280(%rbp)
movq %rax, -0x278(%rbp)
jmp 0x15113
movq -0x280(%rbp), %rax
movq -0x278(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x16290
movq %rax, -0x288(%rbp)
jmp 0x15144
movq -0x288(%rbp), %rax
movq %rax, -0x230(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x4530
jmp 0x15164
cmpq $0x3f4000, -0x230(%rbp) # imm = 0x3F4000
jbe 0x1517c
movq $0x3f4000, -0x230(%rbp) # imm = 0x3F4000
movq -0x230(%rbp), %rdi
incq %rdi
callq 0x4030
movq %rax, -0x290(%rbp)
jmp 0x15194
movq -0x290(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rsi
movq -0x230(%rbp), %rdx
leaq -0x218(%rbp), %rdi
callq 0x44d0
jmp 0x151be
movb $0x0, -0x249(%rbp)
movq -0x248(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq -0x230(%rbp), %rax
movq %rax, -0x2a0(%rbp)
leaq -0x24a(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x46c0
movq -0x268(%rbp), %rdi
movq -0x2a8(%rbp), %rsi
movq -0x2a0(%rbp), %rdx
movq -0x298(%rbp), %rcx
callq 0x4460
jmp 0x15217
leaq -0x24a(%rbp), %rdi
callq 0x4440
movq -0x248(%rbp), %rax
movq %rax, -0x2b0(%rbp)
cmpq $0x0, %rax
je 0x15243
movq -0x2b0(%rbp), %rdi
callq 0x44f0
movb $0x1, -0x249(%rbp)
movl $0x1, -0x228(%rbp)
testb $0x1, -0x249(%rbp)
jne 0x1528b
jmp 0x1527f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x24a(%rbp), %rdi
callq 0x4440
jmp 0x152a9
movq -0x268(%rbp), %rdi
callq 0x4768
jmp 0x1528d
leaq -0x218(%rbp), %rdi
callq 0x4140
movq -0x260(%rbp), %rax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x4140
movq -0x220(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/utilities.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>>, bool)
vector<string> split(string s, string delimiter, bool trim) {
  vector<string> tokens;
  if (trim)
    s.erase(remove(s.begin(), s.end(), ' '), s.end());
  size_t pos = 0;
  string token;
  while ((pos = s.find(delimiter)) != string::npos) {
    token = s.substr(0, pos);
    tokens.push_back(token);
    s.erase(0, pos + delimiter.length());
  }
  tokens.push_back(s);
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xd8(%rbp)
movq %rsi, -0xd0(%rbp)
movq %rdi, -0xc8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x13700
testb $0x1, -0x19(%rbp)
je 0x1541e
movq -0xd0(%rbp), %rdi
callq 0x4350
movq -0xd0(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x4290
movq %rax, -0x40(%rbp)
movb $0x20, -0x41(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x41(%rbp), %rdx
callq 0x162b0
movq %rax, -0xe0(%rbp)
jmp 0x153ae
movq -0xe0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16300
movq -0xd0(%rbp), %rdi
callq 0x4290
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x16300
movq -0xd0(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x40f0
movq %rax, -0xe8(%rbp)
jmp 0x15400
movq -0xe8(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x1541e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1554f
movq $0x0, -0x78(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4560
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x4750
movq %rax, -0x78(%rbp)
cmpq $-0x1, %rax
je 0x15508
movq -0xd0(%rbp), %rsi
movq -0x78(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0xb8(%rbp), %rdi
callq 0x4410
jmp 0x15474
leaq -0x98(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0xb8(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
callq 0x44b0
movq -0xf8(%rbp), %rdi
callq 0x4768
movq -0xc8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x13720
jmp 0x154b6
movq -0xd8(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x100(%rbp)
callq 0x45c0
movq -0x100(%rbp), %rdx
movq -0xd0(%rbp), %rdi
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x4100
jmp 0x154e9
jmp 0x15432
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4768
jmp 0x1554f
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0x13720
jmp 0x1551d
movb $0x1, -0x1a(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4768
testb $0x1, -0x1a(%rbp)
jne 0x1553f
movq -0xc8(%rbp), %rdi
callq 0x13680
movq -0xc0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x13680
movq -0x50(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: urlEncode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string urlEncode(string const &str) {
  char encode_buf[4];
  string result;
  encode_buf[0] = '%';
  result.reserve(str.size());

  // character selection for this algorithm is based on the following url:
  // http://www.blooberry.com/indexdot/html/topics/urlencoding.htm

  for (size_t pos = 0; pos < str.size(); ++pos) {
    switch (str[pos]) {
    default:
      if (str[pos] >= 32 && str[pos] < 127) {
        // character does not need to be escaped
        result += str[pos];
        break;
      }
      // else pass through to next case
    case '$':
    case '&':
    case '+':
    case ',':
    case '/':
    case ':':
    case ';':
    case '=':
    case '?':
    case '@':
    case '"':
    case '<':
    case '>':
    case '#':
    case '%':
    case '{':
    case '}':
    case '|':
    case '\\':
    case '^':
    case '~':
    case '[':
    case ']':
    case '`':
      // the character needs to be encoded
      sprintf(encode_buf + 1, "%02X", str[pos]);
      result += encode_buf;
      break;
    }
  };
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x4560
movb $0x25, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4300
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x45f0
jmp 0x1566f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4300
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1577b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x5c, %eax
ja 0x156e4
movq -0x50(%rbp), %rax
leaq 0xbf07(%rip), %rcx      # 0x215c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4768
jmp 0x15798
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x1572b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movsbl (%rax), %eax
cmpl $0x7f, %eax
jge 0x1572b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x42c0
jmp 0x15729
jmp 0x15768
jmp 0x1572d
leaq -0x13(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movq -0x58(%rbp), %rdi
movsbl (%rax), %edx
leaq 0xc000(%rip), %rsi      # 0x21750
xorl %eax, %eax
callq 0x40c0
movq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43c0
jmp 0x15766
jmp 0x15768
jmp 0x1576a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15677
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1578e
movq -0x38(%rbp), %rdi
callq 0x4768
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: urlDecode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string urlDecode(string const &str) {
  char decode_buf[3];
  string result;
  result.reserve(str.size());

  for (size_t pos = 0; pos < str.size(); ++pos) {
    switch (str[pos]) {
    case '+':
      // convert to space character
      result += ' ';
      break;
    case '%':
      // decode hexidecimal value
      if (pos + 2 < str.size()) {
        decode_buf[0] = str[++pos];
        decode_buf[1] = str[++pos];
        decode_buf[2] = '\0';
        result += static_cast<char>(strtol(decode_buf, nullptr, 16));
      } else {
        // recover from error by not decoding character
        result += '%';
      }
      break;
    default:
      // character does not need to be escaped
      result += str[pos];
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x14(%rbp)
callq 0x4560
movq -0x10(%rbp), %rdi
callq 0x4300
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x45f0
jmp 0x157eb
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4300
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x15927
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
subl $0x25, %eax
je 0x1586a
jmp 0x1582e
movl -0x4c(%rbp), %eax
subl $0x2b, %eax
je 0x15855
jmp 0x158f7
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4768
jmp 0x15944
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x42c0
jmp 0x15865
jmp 0x15914
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4300
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x158e3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
incq %rsi
movq %rsi, -0x30(%rbp)
callq 0x4450
movb (%rax), %al
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
incq %rsi
movq %rsi, -0x30(%rbp)
callq 0x4450
movb (%rax), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x13(%rbp), %rdi
movl $0x10, %edx
callq 0x4770
movq -0x38(%rbp), %rdi
movsbl %al, %esi
callq 0x42c0
jmp 0x158e1
jmp 0x158f5
movq -0x38(%rbp), %rdi
movl $0x25, %esi
callq 0x42c0
jmp 0x158f3
jmp 0x158f5
jmp 0x15914
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4450
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x42c0
jmp 0x15912
jmp 0x15914
jmp 0x15916
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x157f3
movb $0x1, -0x14(%rbp)
testb $0x1, -0x14(%rbp)
jne 0x1593a
movq -0x38(%rbp), %rdi
callq 0x4768
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> tokenize(const string &cnt, char delimiter) {
  vector<string> res;
  istringstream is(cnt);
  string part;
  while (getline(is, part, delimiter))
    res.push_back(part);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x13700
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movl $0x8, %edx
callq 0x4660
jmp 0x15a29
leaq -0x1c8(%rbp), %rdi
callq 0x4560
movsbl -0x11(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x46f0
movq %rax, -0x1e0(%rbp)
jmp 0x15a55
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x44c0
movb %al, -0x1e1(%rbp)
jmp 0x15a73
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x15a7f
jmp 0x15ad6
movq -0x1d8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x13720
jmp 0x15a94
jmp 0x15a35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x15b14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x4768
leaq -0x198(%rbp), %rdi
callq 0x4230
jmp 0x15b14
movb $0x1, -0x12(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x4768
leaq -0x198(%rbp), %rdi
callq 0x4230
testb $0x1, -0x12(%rbp)
jne 0x15b04
movq -0x1d8(%rbp), %rdi
callq 0x13680
movq -0x1d0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1d8(%rbp), %rdi
callq 0x13680
movq -0x1a0(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: replaceAll(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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&)
void replaceAll(std::string &str, const std::string &from,
                const std::string &to) {
  if (from.empty())
    return;
  size_t start_pos = 0;
  while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
    str.replace(start_pos, from.length(), to);
    start_pos += to.length(); // In case 'to' contains 'from', like replacing
                              // 'x' with 'yx'
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4650
testb $0x1, %al
jne 0x15b53
jmp 0x15b55
jmp 0x15bb8
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4750
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
je 0x15bb8
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x41c0
movq -0x18(%rbp), %rdi
callq 0x45c0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x15b5d
addq $0x30, %rsp
popq %rbp
retq
nop
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: findSubStrPosition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&)
int findSubStrPosition(std::string &str, std::string const &subStr,
                       int const &pos) {
  size_t found = str.find(subStr, pos);
  if (found == string::npos)
    return -1;
  return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
callq 0x4750
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x15bfc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15c03
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: UTAP[P]APHTTP/utils/utilities.cpp
// Function: writeObjectToFile(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int writeObjectToFile(const char *object, int size,
                      std::string const &filePath) {
  ofstream file;
  file.open(filePath, fstream::binary);
  if (!file.is_open())
    return -1;
  file.write(object, size);
  file.close();
  return sizeof(object);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x4670
movq -0x238(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x4240
jmp 0x15c50
leaq -0x220(%rbp), %rdi
callq 0x4320
movb %al, -0x239(%rbp)
jmp 0x15c64
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x15ca3
jmp 0x15c70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x230(%rbp)
jmp 0x15cd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x45b0
jmp 0x15cf0
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x4520
jmp 0x15cb9
leaq -0x220(%rbp), %rdi
callq 0x4570
jmp 0x15cc7
movl $0x8, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x45b0
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x46b0
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x4380
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x16c60
cmpq $0x0, -0x30(%rbp)
jbe 0x16bf2
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4410
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x1bde0
jmp 0x16bcd
leaq -0x50(%rbp), %rdi
callq 0x4768
jmp 0x16bf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4768
jmp 0x16c8b
movq -0x90(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
leaq -0x80(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4410
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x44b0
leaq -0x80(%rbp), %rdi
callq 0x4768
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4380
movq %rax, -0x30(%rbp)
cmpl $-0x1, -0x14(%rbp)
jle 0x16c5b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl -0x14(%rbp), %eax
jne 0x16c5b
jmp 0x16c60
jmp 0x16b7c
movq -0x90(%rbp), %rdi
callq 0x45c0
cmpq $0x0, %rax
jbe 0x16c82
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x13720
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jl 0x1b2b8
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x4720
jmp 0x1b2b6
jmp 0x1b2b8
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1b2d4
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x1c030
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b33d
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1c050
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1b32d
movq -0x30(%rbp), %rdi
callq 0x1dad0
movq -0x30(%rbp), %rdi
callq 0x43a0
jmp 0x1b32f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1b2dc
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bf60
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8960
nopl (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x78, %edi
callq 0x4400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movl $0xc8, %esi
callq 0xb460
jmp 0x1b4e1
movq -0x98(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x46c0
movq -0xa8(%rbp), %rdx
leaq 0x5c42(%rip), %rsi      # 0x21157
leaq -0x48(%rbp), %rdi
callq 0x4550
jmp 0x1b520
movq -0xa0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x70(%rbp), %rdi
callq 0x4200
jmp 0x1b536
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xccb0
jmp 0x1b54c
leaq -0x70(%rbp), %rdi
callq 0x4768
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x49(%rbp), %rdi
callq 0x4440
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x8, %rdi
callq 0x41f0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x15040
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0xccf0
jmp 0x1b5ad
leaq -0x90(%rbp), %rdi
callq 0x4768
movq -0x18(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x43a0
jmp 0x1b63d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b61a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b611
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4768
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x49(%rbp), %rdi
callq 0x4440
jmp 0x1b63d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4768
movq -0x20(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9a50
movq -0x130(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0x1bb11
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0x140(%rbp)
callq 0x1c330
movq -0x140(%rbp), %rdi
callq 0x9ba0
movl $0x78, %edi
callq 0x4400
movq %rax, -0x138(%rbp)
jmp 0x1bb44
movq -0x138(%rbp), %rdi
movl $0xc8, %esi
callq 0xb460
jmp 0x1bb57
movq -0x138(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x46c0
movq -0x148(%rbp), %rdx
leaq 0x55c3(%rip), %rsi      # 0x21157
leaq -0xa8(%rbp), %rdi
callq 0x4550
jmp 0x1bba2
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x46c0
movq -0x158(%rbp), %rdx
leaq 0x55a1(%rip), %rsi      # 0x21164
leaq -0xd0(%rbp), %rdi
callq 0x4550
jmp 0x1bbd1
movq -0x150(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0xccb0
jmp 0x1bbed
leaq -0xd0(%rbp), %rdi
callq 0x4768
leaq -0xd1(%rbp), %rdi
callq 0x4440
leaq -0xa8(%rbp), %rdi
callq 0x4768
leaq -0xa9(%rbp), %rdi
callq 0x4440
movq -0x130(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x168(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x160(%rbp)
leaq -0x128(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c360
jmp 0x1bc4f
movq -0x160(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
leaq -0x128(%rbp), %rdx
callq 0x1df20
jmp 0x1bc6b
movq -0x168(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0xccf0
jmp 0x1bc80
leaq -0xf8(%rbp), %rdi
callq 0x4768
leaq -0x128(%rbp), %rdi
callq 0x9ba0
movq -0x88(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9ba0
movq -0x170(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1bd79
movq -0x138(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x43a0
jmp 0x1bd79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1bd39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1bd21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4768
leaq -0xd1(%rbp), %rdi
callq 0x4440
leaq -0xa8(%rbp), %rdi
callq 0x4768
leaq -0xa9(%rbp), %rdi
callq 0x4440
jmp 0x1bd79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1bd6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x4768
leaq -0x128(%rbp), %rdi
callq 0x9ba0
leaq -0x40(%rbp), %rdi
callq 0x9ba0
movq -0x78(%rbp), %rdi
callq 0x46b0
nopl (%rax,%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x78, %edi
callq 0x4400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movl $0x1f4, %esi            # imm = 0x1F4
callq 0xb460
jmp 0x1c139
movq -0xb8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x46c0
movq -0xc8(%rbp), %rdx
leaq 0x4fea(%rip), %rsi      # 0x21157
leaq -0x40(%rbp), %rdi
callq 0x4550
jmp 0x1c178
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x46c0
movq -0xd8(%rbp), %rdx
leaq 0x57b1(%rip), %rsi      # 0x21947
leaq -0x68(%rbp), %rdi
callq 0x4550
jmp 0x1c1a1
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xccb0
jmp 0x1c1b7
leaq -0x68(%rbp), %rdi
callq 0x4768
leaq -0x69(%rbp), %rdi
callq 0x4440
leaq -0x40(%rbp), %rdi
callq 0x4768
leaq -0x41(%rbp), %rdi
callq 0x4440
movq -0xc0(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0x5764(%rip), %rsi      # 0x21958
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xd3b0
movq -0xe0(%rbp), %rsi
leaq 0x5761(%rip), %rdx      # 0x21976
leaq -0x90(%rbp), %rdi
callq 0xd310
jmp 0x1c223
movq -0xe8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xccf0
jmp 0x1c238
leaq -0x90(%rbp), %rdi
callq 0x4768
leaq -0xb0(%rbp), %rdi
callq 0x4768
movq -0x10(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x43a0
jmp 0x1c2fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1c2bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1c2ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4768
leaq -0x69(%rbp), %rdi
callq 0x4440
leaq -0x40(%rbp), %rdi
callq 0x4768
leaq -0x41(%rbp), %rdi
callq 0x4440
jmp 0x1c2fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1c2ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4768
leaq -0xb0(%rbp), %rdi
callq 0x4768
movq -0x18(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x78, %edi
callq 0x4400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movl $0x194, %esi            # imm = 0x194
callq 0xb460
jmp 0x1c641
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x4650
testb $0x1, %al
jne 0x1c82f
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x46c0
movq -0xe8(%rbp), %rdx
leaq 0x4aca(%rip), %rsi      # 0x21157
leaq -0x48(%rbp), %rdi
callq 0x4550
jmp 0x1c698
movq -0xe0(%rbp), %rsi
addq $0x8, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x4200
jmp 0x1c6b1
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x15950
jmp 0x1c6c6
leaq 0x526d(%rip), %rsi      # 0x2193a
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x9a70
jmp 0x1c6df
movq -0xf0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xccb0
jmp 0x1c6f5
leaq -0x70(%rbp), %rdi
callq 0x4768
leaq -0x90(%rbp), %rdi
callq 0x4768
leaq -0xb0(%rbp), %rdi
callq 0x4768
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x49(%rbp), %rdi
callq 0x4440
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
addq $0x8, %rdi
callq 0x41f0
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x15040
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0xccf0
jmp 0x1c76e
leaq -0xd0(%rbp), %rdi
callq 0x4768
jmp 0x1c82f
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x43a0
jmp 0x1c83c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c80a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c801
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c7f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c7e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4768
leaq -0x90(%rbp), %rdi
callq 0x4768
leaq -0xb0(%rbp), %rdi
callq 0x4768
leaq -0x48(%rbp), %rdi
callq 0x4768
leaq -0x49(%rbp), %rdi
callq 0x4440
jmp 0x1c83c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4768
jmp 0x1c83c
movq -0x18(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
nop
// File: UTAP[P]APHTTP/utils/template_parser.cpp
// Function: TemplateParser::TemplateParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TemplateParser::TemplateParser(string _filePath) {
  filePath = _filePath;
  variableCount = 0;
  programName = to_string(TemplateParser::lastParserNum) + SysCmd::fileExtention;
  parserNum = TemplateParser::lastParserNum++;
  code = "";
  parseTemplate();
  makeExecutableTemplate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
callq 0x4560
movq -0x80(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x98(%rbp)
callq 0x4560
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x90(%rbp)
callq 0x9a50
movq -0x80(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4560
movq -0x80(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x78(%rbp)
callq 0x4560
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4060
jmp 0x1dc4b
movq -0x80(%rbp), %rax
movl $0x0, 0x78(%rax)
movl 0x10414(%rip), %esi     # 0x2e070
leaq -0x60(%rbp), %rdi
callq 0x98c0
jmp 0x1dc67
leaq 0x102a2(%rip), %rdx     # 0x2df10
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xd360
jmp 0x1dc7d
movq -0x80(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x44b0
movq -0xa0(%rbp), %rdi
callq 0x4768
leaq -0x60(%rbp), %rdi
callq 0x4768
movq -0x80(%rbp), %rdi
movl 0x103b9(%rip), %eax     # 0x2e070
movl %eax, %ecx
incl %ecx
movl %ecx, 0x103af(%rip)     # 0x2e070
movl %eax, (%rdi)
addq $0x28, %rdi
leaq 0x38c7(%rip), %rsi      # 0x21595
callq 0x4540
jmp 0x1dcd5
movq -0x80(%rbp), %rdi
callq 0x1dd60
jmp 0x1dce0
movq -0x80(%rbp), %rdi
callq 0x1dee0
jmp 0x1dceb
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1dd17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4768
movq -0x78(%rbp), %rdi
callq 0x4768
movq -0x88(%rbp), %rdi
callq 0x4768
movq -0x90(%rbp), %rdi
callq 0x9ba0
movq -0x98(%rbp), %rdi
callq 0x4768
movq -0x70(%rbp), %rdi
callq 0x4768
movq -0x18(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4200
movq -0x68(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x152d0
jmp 0x1dd97
leaq -0x48(%rbp), %rdi
callq 0x4768
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x1de8f
movq -0x70(%rbp), %rdi
movl -0x58(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x1e5b0
movl %eax, -0x78(%rbp)
jmp 0x1ddd9
movq -0x70(%rbp), %rdi
movl -0x78(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x58(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x1e5e0
movl %eax, -0x7c(%rbp)
jmp 0x1ddf4
movl -0x7c(%rbp), %eax
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x5c(%rbp)
jge 0x1de39
jmp 0x1de8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4768
jmp 0x1ded4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4768
jmp 0x1ded4
movq -0x70(%rbp), %rdi
movl -0x58(%rbp), %esi
movl -0x5c(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x1e610
jmp 0x1de4e
movq -0x70(%rbp), %rdi
movl -0x5c(%rbp), %esi
movl -0x60(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x1ea60
jmp 0x1de63
movslq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x100db(%rip), %rdi     # 0x2df50
callq 0x4300
movq %rax, %rcx
movq -0x88(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x58(%rbp)
jmp 0x1dda7
movl -0x58(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4300
movq -0x70(%rbp), %rdi
movl -0x94(%rbp), %esi
movq -0x90(%rbp), %rcx
movl %eax, %edx
callq 0x1e610
jmp 0x1dec2
leaq -0x28(%rbp), %rdi
callq 0x4768
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46b0
nopl (%rax)