LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::fixLogFormat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string AnapacheApp::fixLogFormat(std :: string lf)
{
  if ( (lf.front()=='"') && (lf.back()=='"') )
    lf = lf.substr(1, lf.length()-2);

  lf = GCommon::replace(lf, "\\\"", "\"");
  return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf0(%rbp)
movq %rdi, %rax
movq -0xf0(%rbp), %rdi
movq %rax, -0xe8(%rbp)
movq %rax, %rcx
movq %rcx, -0xe0(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x4130
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x635b
movq -0xf0(%rbp), %rdi
callq 0x4300
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x635b
movq -0xf0(%rbp), %rdi
callq 0x4630
movq -0xf0(%rbp), %rsi
movq %rax, %rcx
subq $0x2, %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0x4450
movq -0xf0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4560
leaq -0x38(%rbp), %rdi
callq 0x47a8
movq -0xf0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x41e0
leaq -0x99(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x46e0
movq -0xf8(%rbp), %rdx
leaq 0xce55(%rip), %rsi      # 0x131e1
leaq -0x98(%rbp), %rdi
callq 0x5700
jmp 0x639a
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x46e0
movq -0x100(%rbp), %rdx
leaq 0xce27(%rip), %rsi      # 0x131e2
leaq -0xd0(%rbp), %rdi
callq 0x5700
jmp 0x63c9
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x98(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x11ef0
jmp 0x63ec
movq -0xf0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4560
leaq -0x58(%rbp), %rdi
callq 0x47a8
leaq -0xd0(%rbp), %rdi
callq 0x47a8
leaq -0xd1(%rbp), %rdi
callq 0x4490
leaq -0x98(%rbp), %rdi
callq 0x47a8
leaq -0x99(%rbp), %rdi
callq 0x4490
leaq -0x78(%rbp), %rdi
callq 0x47a8
movq -0xe8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x4280
movq -0xe0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x64bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x64a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x47a8
leaq -0xd1(%rbp), %rdi
callq 0x4490
leaq -0x98(%rbp), %rdi
callq 0x47a8
leaq -0x99(%rbp), %rdi
callq 0x4490
leaq -0x78(%rbp), %rdi
callq 0x47a8
movq -0xa8(%rbp), %rdi
callq 0x46c0
// File: gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::totalQuery_Initialize(AnapacheApp::AnalizerOptions)
void AnapacheApp::totalQuery_Initialize(AnalizerOptions opts)
{
  totalQuery_data.total_queries = 0;
  totalQuery_data.started = false;
  totalQuery_data.currentAnalysis = 0;
  totalQuery_data.currentQueryStrike = 0;
  totalQuery_data.maxQueryStrike = 0;
  totalQuery_data.firstone = 0;
  totalQuery_data.lastone = 0;
  totalQuery_data.maxQueryStrikeHits = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movb $0x0, 0x40(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x70(%rax)
popq %rbp
retq
nopl (%rax)
// File: gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::totalQuery_Input(long, 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>>>>>&, AnapacheApp::AnalizerOptions)
void AnapacheApp::totalQuery_Input(time_t moment, std::map<std::string, std::string>& parsed, AnalizerOptions opts)
{
  totalQuery_data.total_queries++;
  if (!totalQuery_data.started)
    totalQuery_data.firstone = moment;

  totalQuery_data.lastone = moment;
  totalQuery_data.started = true;
  if (totalQuery_data.currentAnalysis == moment)
    {
      totalQuery_data.currentQueryStrike++;
      if (totalQuery_data.currentQueryStrike > totalQuery_data.maxQueryStrikeHits)
	{
	  totalQuery_data.maxQueryStrikeHits = totalQuery_data.currentQueryStrike;
	  totalQuery_data.maxQueryStrike = moment;
	}
    }
  else
    {
      totalQuery_data.currentQueryStrike=1;
    }

  totalQuery_data.currentAnalysis = moment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
testb $0x1, 0x40(%rax)
jne 0x6f79
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movb $0x1, 0x40(%rax)
movq 0x58(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6fc3
movq -0x28(%rbp), %rcx
movq 0x60(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x60(%rcx)
movq 0x60(%rcx), %rax
cmpq 0x70(%rcx), %rax
jbe 0x6fc1
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x68(%rax)
jmp 0x6fcf
movq -0x28(%rbp), %rax
movq $0x1, 0x60(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopl (%rax)
// File: gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::parseTime(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
time_t AnapacheApp::parseTime(std::string strTime)
{
  /* We must improve it a little bit */
  std::string format;
  struct tm tm;
  time_t now = time(NULL);
  localtime_r(&now, &tm);

  if (strTime == "now")
    return now;
  else if (strTime == "yesterday")
    return now-86400;

  if (strTime.find('/') == std::string::npos)
    format = "%H:%M:%S";
  else
    format ="%d/%m/%Y %H:%M:%S";

  char *conv = strptime(strTime.c_str(), format.c_str(), &tm);

  time_t newtime = mktime(&tm);
  if ( (conv == NULL) && (newtime == now) )
    return 0;

  return newtime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x45e0
xorl %eax, %eax
movl %eax, %edi
callq 0x43f0
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4240
movq -0xa8(%rbp), %rdi
leaq 0xb3bc(%rip), %rsi      # 0x13277
callq 0x8a40
movb %al, -0x99(%rbp)
jmp 0x7ec8
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x7ed4
jmp 0x7f08
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x8017
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x47a8
jmp 0x802d
movq -0xa8(%rbp), %rdi
leaq 0xb365(%rip), %rsi      # 0x1327b
callq 0x8a40
movb %al, -0xa9(%rbp)
jmp 0x7f23
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x7f2f
jmp 0x7f4c
movq -0x78(%rbp), %rax
subq $0x15180, %rax          # imm = 0x15180
movq %rax, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x8017
jmp 0x7f4e
movq -0xa8(%rbp), %rdi
movl $0x2f, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4590
cmpq $-0x1, %rax
jne 0x7f7d
leaq 0xb31e(%rip), %rsi      # 0x1328e
leaq -0x38(%rbp), %rdi
callq 0x45c0
jmp 0x7f7b
jmp 0x7f91
leaq 0xb301(%rip), %rsi      # 0x13285
leaq -0x38(%rbp), %rdi
callq 0x45c0
jmp 0x7f8f
jmp 0x7f91
movq -0xa8(%rbp), %rdi
callq 0x41d0
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41d0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
leaq -0x70(%rbp), %rdx
callq 0x4090
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x42a0
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x8002
movq -0x98(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0x8002
movq $0x0, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x8017
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x47a8
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::summary()
void AnapacheApp::summary()
{
  if (fromDate)
    std::cout << "From: "<< GCommon::put_time("%d/%m/%Y %H:%M:%S", fromDate) << std::endl;
  if (toDate)
    std::cout << "To: "<< GCommon::put_time("%d/%m/%Y %H:%M:%S", toDate) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x8225
movq 0x13e74(%rip), %rdi     # 0x1bfb0
leaq 0xb154(%rip), %rsi      # 0x13297
callq 0x4410
movq %rax, -0xc0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x46e0
movq -0xb8(%rbp), %rdx
leaq 0xb118(%rip), %rsi      # 0x13285
leaq -0x48(%rbp), %rdi
callq 0x5700
jmp 0x8178
movq -0xb0(%rbp), %rax
movq 0x28(%rax), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x100f0
jmp 0x8192
movq -0xc0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x43d0
movq %rax, -0xc8(%rbp)
jmp 0x81ab
movq -0xc8(%rbp), %rdi
movq 0x13dbf(%rip), %rsi     # 0x1bf78
callq 0x4470
jmp 0x81c0
leaq -0x28(%rbp), %rdi
callq 0x47a8
leaq -0x48(%rbp), %rdi
callq 0x47a8
leaq -0x49(%rbp), %rdi
callq 0x4490
jmp 0x8225
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8217
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x820e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x47a8
leaq -0x48(%rbp), %rdi
callq 0x47a8
leaq -0x49(%rbp), %rdi
callq 0x4490
jmp 0x8342
movq -0xb0(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8339
movq 0x13d72(%rip), %rdi     # 0x1bfb0
leaq 0xb059(%rip), %rsi      # 0x1329e
callq 0x4410
movq %rax, -0xd8(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x46e0
movq -0xd0(%rbp), %rdx
leaq 0xb013(%rip), %rsi      # 0x13285
leaq -0xa0(%rbp), %rdi
callq 0x5700
jmp 0x8280
movq -0xb0(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x100f0
jmp 0x829d
movq -0xd8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x43d0
movq %rax, -0xe0(%rbp)
jmp 0x82b6
movq -0xe0(%rbp), %rdi
movq 0x13cb4(%rip), %rsi     # 0x1bf78
callq 0x4470
jmp 0x82cb
leaq -0x80(%rbp), %rdi
callq 0x47a8
leaq -0xa0(%rbp), %rdi
callq 0x47a8
leaq -0xa1(%rbp), %rdi
callq 0x4490
jmp 0x8339
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x832b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x831f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x47a8
leaq -0xa0(%rbp), %rdi
callq 0x47a8
leaq -0xa1(%rbp), %rdi
callq 0x4490
jmp 0x8342
addq $0xe0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46c0
nopl (%rax,%rax)
// File: gasparfm[P]anapache/./lib/ini/ini.hpp
// Function: INI::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string trim(const std::string& s)
{
  char p[] = " \t\r\n";
  long sp = 0;
  long ep = s.length() - 1;
  for (; sp <= ep; ++sp)
    if (!strchr(p, s[sp])) break;
  for (; ep >= 0; --ep)
    if (!strchr(p, s[ep])) break;
  return s.substr(sp, ep-sp+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x9604(%rip), %eax      # 0x133c5
movl %eax, -0x15(%rbp)
movb 0x95ff(%rip), %al       # 0x133c9
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4630
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x9e29
leaq -0x15(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44b0
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x4190
cmpq $0x0, %rax
jne 0x9e19
jmp 0x9e29
jmp 0x9e1b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9de6
jmp 0x9e2b
cmpq $0x0, -0x28(%rbp)
jl 0x9e6b
leaq -0x15(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44b0
movq -0x48(%rbp), %rdi
movsbl (%rax), %esi
callq 0x4190
cmpq $0x0, %rax
jne 0x9e5b
jmp 0x9e6b
jmp 0x9e5d
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9e2b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x4450
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gasparfm[P]anapache/./lib/ini/ini.hpp
// Function: INI::Parser::parseSLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&)
inline void 
Parser::parseSLine(std::string& sname, size_t& depth)
{
  depth = 0;
  for (; depth < line_.length(); ++depth)
    if (line_[depth] != '[') break;

  sname = line_.substr(depth, line_.length() - 2*depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0x4630
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x9f21
movq -0x40(%rbp), %rdi
addq $0x2b0, %rdi            # imm = 0x2B0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4780
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x9f0f
jmp 0x9f21
jmp 0x9f11
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x9ec7
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x2b0, %rax            # imm = 0x2B0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0x4630
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq %rax
subq %rax, %rcx
leaq -0x38(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4560
leaq -0x38(%rbp), %rdi
callq 0x47a8
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/gcommon.cpp
// Function: GCommon::(anonymous namespace)::_findFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::list<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>>>> const&, 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>>>>> const&)
bool _findFile(std::string &file, const std::list<std::string>& paths, const std::map<std::string, std::string>& replacements)
    {
      for (auto p : paths)
	{
	  p = replace(p, replacements);
	  if (file_exists(p.c_str())==1)
	    {
	      file = p;
	      return true;
	    }
	}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x109c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x109f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10a20
testb $0x1, %al
jne 0xfdbf
jmp 0xff3f
leaq -0x30(%rbp), %rdi
callq 0x10a50
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x41e0
movq -0xe8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x41e0
jmp 0xfdf0
movq -0x20(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x106f0
jmp 0xfe02
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
movl %r8d, %ecx
callq 0x12440
jmp 0xfe27
leaq -0x58(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
leaq -0x78(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0x4560
movq -0x100(%rbp), %rdi
callq 0x47a8
leaq -0xd8(%rbp), %rdi
callq 0x8830
leaq -0x98(%rbp), %rdi
callq 0x47a8
movq -0xf8(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x11980
movw %ax, -0xea(%rbp)
jmp 0xfe83
movw -0xea(%rbp), %ax
cwtl
cmpl $0x1, %eax
jne 0xff03
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4060
jmp 0xfe9f
movb $0x1, -0x1(%rbp)
movl $0x1, -0xdc(%rbp)
jmp 0xff0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xff34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xfef5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x8830
leaq -0x98(%rbp), %rdi
callq 0x47a8
jmp 0xff34
movl $0x0, -0xdc(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x47a8
movl -0xdc(%rbp), %eax
testl %eax, %eax
je 0xff24
jmp 0xff22
jmp 0xff41
jmp 0xff26
leaq -0x30(%rbp), %rdi
callq 0x10a80
jmp 0xfda9
leaq -0x58(%rbp), %rdi
callq 0x47a8
jmp 0xff4f
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x46c0
nopl (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/gcommon.cpp
// Function: GCommon::put_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long)
std::string put_time(std::string format, time_t tim)
  {
    struct tm tm;
    if (tim==0)
      tim = time (NULL);

    localtime_r(&tim, &tm);
    return std::put_time(&tm, format.c_str());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10127
xorl %eax, %eax
movl %eax, %edi
callq 0x43f0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4240
movq -0x68(%rbp), %rdi
callq 0x41d0
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq -0x50(%rbp), %rsi
callq 0x10160
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/gcommon.hpp
// Function: std::put_time[abi:cxx11](tm const*, char const*)
static std::string put_time( const std::tm* tmb, const char* fmt )
    {
      std::string s( 128, '\0' );
      size_t written;
      while( !(written=strftime( &s[0], s.size(), fmt, tmb ) ) )
        s.resize( s.size() + 128 );
      s[written] = '\0';

      return s.c_str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x46e0
movq -0x68(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x80, %esi
xorl %edx, %edx
callq 0x11260
jmp 0x101a5
leaq -0x39(%rbp), %rdi
callq 0x4490
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x4780
movq %rax, -0x80(%rbp)
jmp 0x101c1
leaq -0x38(%rbp), %rdi
callq 0x42d0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x4360
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x101f1
jmp 0x10243
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x42d0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
subq $-0x80, %rsi
callq 0x45d0
jmp 0x10216
jmp 0x101ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x4490
jmp 0x102d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x102d0
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4780
movq %rax, -0x90(%rbp)
jmp 0x10259
movq -0x90(%rbp), %rax
movb $0x0, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x41d0
movq %rax, -0xa0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x46e0
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x5700
jmp 0x1029c
leaq -0x59(%rbp), %rdi
callq 0x4490
leaq -0x38(%rbp), %rdi
callq 0x47a8
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x4490
leaq -0x38(%rbp), %rdi
callq 0x47a8
movq -0x48(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/gcommon.cpp
// Function: GCommon::GlobalSettings::basics(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void GlobalSettings::basics(std::string programName, std::string programShortName, std::string programFile, std::string programVersion)
  {
    storage.insert({"name", programName});
    storage.insert({"sname", programShortName});
    storage.insert({"exec", programFile});
    storage.insert({"version", programVersion});
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdx, %rax
movq %rdi, %rdx
movq %rsi, -0x1a0(%rbp)
movq %rax, -0x198(%rbp)
movq %rcx, -0x190(%rbp)
movq %rdx, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x3113(%rip), %rsi      # 0x13440
leaq -0x60(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x107e0
movq -0x188(%rbp), %rsi
leaq 0xc125(%rip), %rdi      # 0x1c470
callq 0x88d0
movb %dl, -0x179(%rbp)
movq %rax, -0x178(%rbp)
jmp 0x1035f
movb -0x179(%rbp), %al
movq -0x178(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8970
movq -0x1a0(%rbp), %rdx
leaq 0x30b5(%rip), %rsi      # 0x1343f
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x10880
movq -0x1b8(%rbp), %rsi
leaq 0xc0c5(%rip), %rdi      # 0x1c470
callq 0x88d0
movb %dl, -0x1a9(%rbp)
movq %rax, -0x1a8(%rbp)
jmp 0x103bf
movb -0x1a9(%rbp), %al
movq -0x1a8(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movb %al, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8970
movq -0x198(%rbp), %rdx
leaq 0x3052(%rip), %rsi      # 0x13445
leaq -0x110(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x107e0
movq -0x1d0(%rbp), %rsi
leaq 0xc05c(%rip), %rdi      # 0x1c470
callq 0x88d0
movb %dl, -0x1c1(%rbp)
movq %rax, -0x1c0(%rbp)
jmp 0x10428
movb -0x1c1(%rbp), %al
movq -0x1c0(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movb %al, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x8970
movq -0x190(%rbp), %rdx
leaq 0x2fee(%rip), %rsi      # 0x1344a
leaq -0x160(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x10920
movq -0x1e8(%rbp), %rsi
leaq 0xbff3(%rip), %rdi      # 0x1c470
callq 0x88d0
movb %dl, -0x1d9(%rbp)
movq %rax, -0x1d8(%rbp)
jmp 0x10491
movb -0x1d9(%rbp), %al
movq -0x1d8(%rbp), %rcx
movq %rcx, -0x170(%rbp)
movb %al, -0x168(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x8970
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8970
jmp 0x10523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8970
jmp 0x10523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x8970
jmp 0x10523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x8970
movq -0x68(%rbp), %rdi
callq 0x46c0
nopl (%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: human_size(char*, long double)
char *human_size(char *store, long double size)
{
  static char units[10][6]={"bytes","Kb","Mb","Gb","Tb","Pb","Eb","Zb","Yb","Bb"};  
  int i= 0;

  while (size>1024) {
    size = size /1024;
    i++;
  }

  sprintf(store,"%.2Lf%s",size, units[i]);

  return store;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
movl $0x0, -0x24(%rbp)
fldt -0x20(%rbp)
flds 0x1ba2(%rip)            # 0x13454
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x118d5
jmp 0x118bc
fldt -0x20(%rbp)
flds 0x1b93(%rip)            # 0x13458
fmulp %st, %st(1)
fstpt -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x118a9
movq -0x8(%rbp), %rdi
fldt -0x20(%rbp)
movslq -0x24(%rbp), %rax
leaq 0xab19(%rip), %rdx      # 0x1c400
imulq $0x6, %rax, %rax
addq %rax, %rdx
movq %rsp, %rax
fstpt (%rax)
leaq 0x1b62(%rip), %rsi      # 0x1345c
xorl %eax, %eax
callq 0x40d0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: file_size(char*)
long long file_size(char *fileName)
{
  FILE *fich;

  fich=fopen(fileName,"r");
  if (fich==NULL)
    return -1;

  fseek(fich, 0L, SEEK_END);
  size_t res=ftell(fich);

  fclose(fich);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1930(%rip), %rsi      # 0x13257
callq 0x4520
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11941
movq $-0x1, -0x8(%rbp)
jmp 0x11971
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x44d0
movq -0x18(%rbp), %rdi
callq 0x4030
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4420
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: file_exists(char const*)
short file_exists(const char *filename)
{
  int fd=open(filename, O_RDONLY);
  if (fd==-1)
    {
      if (errno==2)		/* If errno==2 it means file not found */
	return 0;		/* otherwise there is another error at */
      else 			/* reading file, for example path not  */
	return -1;		/* found, no memory, etc */
    }
  close(fd);			/* If we close the file, it exists */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4320
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x119bc
callq 0x4070
cmpl $0x2, (%rax)
jne 0x119b4
movw $0x0, -0x2(%rbp)
jmp 0x119ca
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x119ca
movl -0x14(%rbp), %edi
callq 0x4760
movw $0x1, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: human_size_multiplier(char const*)
long long human_size_multiplier(const char *human)
{
  static char units[10][3]={"By","Kb","Mb","Gb","Tb","Pb","Eb","Zb","Yb","Bb"};
  short i;
  long long res=1;
  for (i=0; i<10; i++)
    {
      if (strcmp(human, units[i])==0)
	return res;
      res*=1024;
    }
  return 1;			/* If we reach here, there was no match, so we return bytes*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x1, -0x20(%rbp)
movw $0x0, -0x12(%rbp)
movswl -0x12(%rbp), %eax
cmpl $0xa, %eax
jge 0x11ab8
movq -0x10(%rbp), %rdi
movswq -0x12(%rbp), %rax
leaq 0xa9bd(%rip), %rsi      # 0x1c440
imulq $0x3, %rax, %rax
addq %rax, %rsi
callq 0x45f0
cmpl $0x0, %eax
jne 0x11a9e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11ac0
movq -0x20(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x11a6a
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: human_to_bytes(char const*)
long long human_to_bytes(const char *human)
{
  long double n;
  char unit[3];
  
  sscanf(human, "%Lf%c%c", &n, &unit[0], &unit[1]);

  unit[0]=toupper(unit[0]);	/* Uppercase, please */
  unit[1]=tolower(unit[1]);	/* Lowercase, please */
  unit[2]='\0';
  
  return n * human_size_multiplier(unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x22(%rbp), %r8
leaq 0x1979(%rip), %rsi      # 0x13464
xorl %eax, %eax
leaq -0x20(%rbp), %rdx
leaq -0x23(%rbp), %rcx
movq %rcx, -0x50(%rbp)
callq 0x4400
movsbl -0x23(%rbp), %edi
callq 0x4720
movb %al, -0x23(%rbp)
movsbl -0x22(%rbp), %edi
callq 0x4610
movq -0x50(%rbp), %rdi
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
fldt -0x20(%rbp)
fstpt -0x48(%rbp)
callq 0x11a50
fldt -0x48(%rbp)
movq %rax, -0x38(%rbp)
fildll -0x38(%rbp)
fmulp %st, %st(1)
fnstcw -0x3a(%rbp)
movzwl -0x3a(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x3c(%rbp)
fldcw -0x3c(%rbp)
fistpll -0x30(%rbp)
fldcw -0x3a(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: getHomeDir()
char *getHomeDir()
{
  static char *home = NULL;
  
  if (home==NULL)
    home = getenv("HOME") ;

  if (home==NULL)
    {
      struct passwd *pw = getpwuid(getuid());
      if (pw!=NULL) 
	home = pw->pw_dir;
    }

  return home;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xa948(%rip)      # 0x1c4b8
jne 0x11b85
leaq 0x18f3(%rip), %rdi      # 0x1346c
callq 0x4550
movq %rax, 0xa933(%rip)      # 0x1c4b8
cmpq $0x0, 0xa92b(%rip)      # 0x1c4b8
jne 0x11bb7
callq 0x4220
movl %eax, %edi
callq 0x4510
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11bb5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0xa903(%rip)      # 0x1c4b8
jmp 0x11bb7
movq 0xa8fa(%rip), %rax      # 0x1c4b8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: makePath(char**, char const*, char const*)
char* makePath(char **out, const char *directory, const char *file)
{
  size_t dlen=strlen(directory);
  size_t flen=strlen(file);
  if (*out!=NULL)
    {
      free(*out);
      *out=NULL;
    }

  *out=(char*)malloc(dlen+flen+2);
  if ( (dlen>0) && (directory[dlen-1]!='/') )
    sprintf(*out, "%s/%s", directory, file);
  else
    sprintf(*out, "%s%s", directory, file);


  return *out;
}

// 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 0x41f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11c1f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4530
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
addq $0x2, %rdi
callq 0x45b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jbe 0x11c75
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x11c75
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1805(%rip), %rsi      # 0x13471
movb $0x0, %al
callq 0x40d0
jmp 0x11c92
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x17ec(%rip), %rsi      # 0x13477
movb $0x0, %al
callq 0x40d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: copyFile(char*, char*)
int copyFile(char *origin, char *destination)
{
  int forigin;
  int fdest;
  char buffer[512];

  int result=0;
  size_t bytes;

  forigin=open(origin, O_RDONLY);
  if (forigin<0)
    return -1;

  fdest=open(destination, O_WRONLY | O_CREAT, 0600);
  if (fdest!=-1)
    {
      while ( (bytes=read(forigin, buffer, (size_t)512))>0)
	{
	  if (write(fdest, buffer, bytes)<0)
	    {
	      result=-4;
	      break;
	    }	  
	}
      if (bytes<0)
	  result=-5;
      
      close(fdest);
    }
  else
    result=-2;
  close(forigin);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x224(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4320
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x11cdf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d83
movq -0x18(%rbp), %rdi
movl $0x41, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x4320
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0x11d68
jmp 0x11cff
movl -0x1c(%rbp), %edi
leaq -0x220(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x4600
movq %rax, -0x230(%rbp)
cmpq $0x0, %rax
jbe 0x11d4a
movl -0x20(%rbp), %edi
leaq -0x220(%rbp), %rsi
movq -0x230(%rbp), %rdx
callq 0x4160
cmpq $0x0, %rax
jge 0x11d48
movl $0xfffffffc, -0x224(%rbp) # imm = 0xFFFFFFFC
jmp 0x11d4a
jmp 0x11cff
cmpq $0x0, -0x230(%rbp)
jae 0x11d5e
movl $0xfffffffb, -0x224(%rbp) # imm = 0xFFFFFFFB
movl -0x20(%rbp), %edi
callq 0x4760
jmp 0x11d72
movl $0xfffffffe, -0x224(%rbp) # imm = 0xFFFFFFFE
movl -0x1c(%rbp), %edi
callq 0x4760
movl -0x224(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nop
// File: gasparfm[P]anapache/lib/gcommon/cfileutils.cpp
// Function: file_get_contents(char**, char*, int)
int file_get_contents(char **data, char *fileName, int freeNotNull)
{
  long long fileSize;
  int fd;
  int totalRead;

  if (!file_exists(fileName))
    return -1;
  
  fileSize=file_size(fileName);
  if (fileSize==-1)
    return -2;
  
  fd=open(fileName, O_RDONLY);
  if (fd<0)
    return -3;

  if ( (*data!=NULL) && (freeNotNull) )
    {
      free(*data);
      *data=NULL;
    }
  *data=(char*)malloc(fileSize+1);
  totalRead=read(fd, *data, fileSize);
  close(fd);

  if (totalRead<0)
    return -4;
  else if (totalRead!=fileSize)
    return -5;
    
  (*data)[fileSize]='\0';

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11980
cmpw $0x0, %ax
jne 0x11e0e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11ee6
movq -0x18(%rbp), %rdi
callq 0x11910
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x11e2e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x11ee6
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4320
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x11e50
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x11ee6
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11e77
cmpl $0x0, -0x1c(%rbp)
je 0x11e77
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4530
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x45b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x4600
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %edi
callq 0x4760
cmpl $0x0, -0x30(%rbp)
jge 0x11ebb
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x11ee6
movslq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x11ece
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x11ee6
jmp 0x11ed0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gasparfm[P]anapache/lib/gcommon/gstr.cpp
// Function: GCommon::replace(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
std::string replace(std::string source, std::string from, std::string to, int offset, int times)
  {
    int total = 0;
    std::string::size_type pos=offset;

    do
      {
	pos = source.find(from, pos);

	if (pos == std::string::npos)
	  break;

	source.replace(pos, from.length(), to);
	pos+=to.size();

      } while ( (times==0) || (++total<times) );

    return source;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rdx
callq 0x4790
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
jne 0x11f54
jmp 0x11fae
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x4630
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
movq %rax, %rdx
callq 0x4180
movq -0x60(%rbp), %rdi
callq 0x42d0
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x1, %al
cmpl $0x0, -0x28(%rbp)
movb %al, -0x69(%rbp)
je 0x11fa7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl -0x28(%rbp), %eax
setl %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x11f36
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x4280
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::initialize()
void Anf::initialize() {
        Formula::initialize();
        symbols_.clear();
        terms_.clear();
        equations_.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x54db0
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0xf9d0
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0xf9d0
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0xf9d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::append_equation()
void Anf::append_equation() {
        assert(terms_.size() < UINT32_MAX);
        equations_.push_back((uint32_t)terms_.size());
        // add the constant term
        terms_.push_back((uint32_t)symbols_.size());
        symbols_.push_back(literal_t__constant(0));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x90, %rdi
callq 0xf9f0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jae 0xde9c
jmp 0xdebb
leaq 0x4d161(%rip), %rdi     # 0x5b004
leaq 0x4d175(%rip), %rsi     # 0x5b01f
movl $0x34, %edx
leaq 0x4d17b(%rip), %rcx     # 0x5b031
callq 0xd1c0
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x28(%rbp)
addq $0x90, %rdi
callq 0xf9f0
movq -0x28(%rbp), %rdi
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xfa10
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0x20(%rbp)
addq $0x78, %rdi
callq 0xf9f0
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xfa10
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
leaq 0x4da53(%rip), %rsi     # 0x5b974
callq 0xfa40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::encode_negations_(bal::VariablesArray&)
void Anf::encode_negations_(VariablesArray& template_) {
        literalid_t* variables = template_.data();
        for (auto i = 0; i < template_.size(); i++) {
            if (literal_t__is_negation(variables[i])) {
                append_equation();
                append_equation_term(variables[i]);
                variables[i] = complete_equation(LITERALID_UNASSIGNED, false);
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10310
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0xf87e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xf871
movq -0x28(%rbp), %rdi
callq 0xde70
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0xe600
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0xe670
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xf873
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf80c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::evaluate(bal::VariablesArray const&, bal::VariablesArray const&, bal::VariablesArray const&) const
VariablesArray Anf::evaluate(const VariablesArray& value_template, const VariablesArray& value,
                                 const VariablesArray& result_template) const {
        assert(variables_size() > 0);
        VariablesArray variables(variables_size(), 1);
        variables.assign_sequence();
        variables.assign_template_from(value_template, value);
        
        evaluate(variables);
        
        VariablesArray result(result_template);
        variables.assign_template_into(result_template, result);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x0, %eax
jbe 0xf8cf
jmp 0xf8ee
leaq 0x4bbbd(%rip), %rdi     # 0x5b493
leaq 0x4b742(%rip), %rsi     # 0x5b01f
movl $0x165, %edx            # imm = 0x165
leaq 0x4bbbf(%rip), %rcx     # 0x5b4a8
callq 0xd1c0
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x1, %edx
callq 0x10330
movq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x103a0
jmp 0xf91c
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x103f0
jmp 0xf92f
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf090
jmp 0xf93e
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
movq -0x28(%rbp), %rsi
callq 0x106c0
jmp 0xf951
movq -0x70(%rbp), %rdx
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x10700
jmp 0xf964
movb $0x1, -0x55(%rbp)
testb $0x1, -0x55(%rbp)
jne 0xf99e
jmp 0xf995
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xf9b4
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x10850
jmp 0xf9b4
movq -0x70(%rbp), %rdi
callq 0x10850
leaq -0x48(%rbp), %rdi
callq 0x10850
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x10850
movq -0x50(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::is_incomplete_last_equation_() const
void Anf::is_incomplete_last_equation_() const {
        assert(equations_.size() > 0);
        assert(terms_size_(equations_.size() - 1) > 0);
        assert(symbols_size_(equations_[equations_.size() - 1]) == 1);
        assert(literal_t__is_constant(symbols_[terms_[equations_[equations_.size() - 1]]]));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xa8, %rdi
callq 0xf9f0
cmpq $0x0, %rax
jbe 0xfad8
jmp 0xfaf7
leaq 0x4ba39(%rip), %rdi     # 0x5b518
leaq 0x4b539(%rip), %rsi     # 0x5b01f
movl $0x16, %edx
leaq 0x4ba3c(%rip), %rcx     # 0x5b52e
callq 0xd1c0
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0xf9f0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xfc30
cmpq $0x0, %rax
jbe 0xfb1f
jmp 0xfb3e
leaq 0x4ba3c(%rip), %rdi     # 0x5b562
leaq 0x4b4f2(%rip), %rsi     # 0x5b01f
movl $0x17, %edx
leaq 0x4b9f5(%rip), %rcx     # 0x5b52e
callq 0xd1c0
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x18(%rbp)
addq $0xa8, %rdi
callq 0xf9f0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x102a0
movq -0x10(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0xfd70
cmpq $0x1, %rax
jne 0xfb80
jmp 0xfb9f
leaq 0x4ba02(%rip), %rdi     # 0x5b589
leaq 0x4b491(%rip), %rsi     # 0x5b01f
movl $0x18, %edx
leaq 0x4b994(%rip), %rcx     # 0x5b52e
callq 0xd1c0
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x78, %rax
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0x28(%rbp)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x30(%rbp)
addq $0xa8, %rdi
callq 0xf9f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x102a0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x102a0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x102a0
cmpl $0x1, (%rax)
ja 0xfc05
jmp 0xfc24
leaq 0x4b9b3(%rip), %rdi     # 0x5b5bf
leaq 0x4b40c(%rip), %rsi     # 0x5b01f
movl $0x19, %edx
leaq 0x4b90f(%rip), %rcx     # 0x5b52e
callq 0xd1c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::remove_last_equation_()
void Anf::remove_last_equation_() {
        is_incomplete_last_equation_();
        size_t terms_index = equations_[equations_.size() - 1];
        symbols_.erase(symbols_.begin() + terms_[terms_index], symbols_.end());
        terms_.erase(terms_.begin() + terms_index, terms_.end());
        equations_.erase(equations_.end() - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xfab0
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0xb8(%rbp)
addq $0xa8, %rdi
callq 0xf9f0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xfd50
movq -0xa0(%rbp), %rdi
movl (%rax), %eax
movq %rax, -0x10(%rbp)
movq %rdi, %rax
addq $0x78, %rax
movq %rax, -0xb0(%rbp)
addq $0x78, %rdi
callq 0x10a10
movq -0xa0(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
callq 0xfd50
movl (%rax), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x10a40
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10a80
movq -0xa0(%rbp), %rdi
addq $0x78, %rdi
callq 0x10ce0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10a80
movq -0xb0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x10980
movq -0xa0(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0xa8(%rbp)
addq $0x90, %rdi
callq 0x10a10
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x10a40
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x10a80
movq -0xa0(%rbp), %rdi
addq $0x90, %rdi
callq 0x10ce0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x10a80
movq -0xa8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x10980
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x98(%rbp)
addq $0xa8, %rdi
callq 0x10ce0
movq %rax, -0x88(%rbp)
leaq -0x88(%rbp), %rdi
movl $0x1, %esi
callq 0x111f0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10a80
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x10ac0
movq %rax, -0x90(%rbp)
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)