LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::ipCount_Results(AnapacheApp::AnalizerOptions)
void AnapacheApp::ipCount_Results(AnalizerOptions opts)
{
  std::cout << "Found "<<ipCount_data.queryCount.size()<<" different IPs"<<std::endl;
  std::cout << "Ordering IPs.."<<std::endl;
  std::vector < std::pair<std::string, unsigned long> >orderedIps;
  for (auto ip : ipCount_data.queryCount)
    {
      auto pos = orderedIps.begin();

      while ( (pos!=orderedIps.end()) && (pos->second<ip.second) )
      	pos++;
      orderedIps.insert(pos, ip);
      /* std:: cout << ip.first <<": "<<ip.second<<std::endl; */
    }
  std::cout << "ready!"<<std::endl;
  for (auto ip : orderedIps)
    {
      std:: cout << ip.first <<": "<<ip.second<<std::endl;
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x92f2(%rip), %r14      # 0xdfb0
leaq 0x463e(%rip), %rsi      # 0x9303
movq %r14, %rdi
callq 0x3330
movq 0xa0(%rbx), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x4627(%rip), %rsi      # 0x930a
movq %rax, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3190
leaq 0x461f(%rip), %rsi      # 0x9319
movq %r14, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3190
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x90(%rbx), %r15
subq $-0x80, %rbx
leaq 0x18(%rsp), %r12
leaq 0x40(%rsp), %r13
cmpq %rbx, %r15
je 0x4d94
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x550a
movq (%rsp), %rbp
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rax, %rbp
je 0x4d5e
cmpq %rcx, 0x20(%rbp)
jae 0x4d5e
addq $0x28, %rbp
jmp 0x4d4d
movq %r13, %rdi
movq %r12, %rsi
callq 0x552a
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x6ca8
movq %r13, %rdi
callq 0x35d8
movq %r12, %rdi
callq 0x35d8
movq %r15, %rdi
callq 0x3220
movq %rax, %r15
jmp 0x4d2e
movq 0x9215(%rip), %rdi      # 0xdfb0
leaq 0x4586(%rip), %rsi      # 0x9328
callq 0x3330
movq %rax, %rdi
callq 0x3190
movq (%rsp), %rbx
movq 0x8(%rsp), %r13
leaq 0x18(%rsp), %r14
movq 0x91ec(%rip), %r15      # 0xdfb0
leaq 0x42fa(%rip), %r12      # 0x90c5
cmpq %r13, %rbx
je 0x4e14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x554a
movq %r15, %rdi
movq %r14, %rsi
callq 0x32f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3330
movq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x35d8
addq $0x28, %rbx
jmp 0x4dcb
movq %rsp, %rdi
callq 0x556a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e2f
jmp 0x4e2f
movq %rax, %rbx
jmp 0x4e52
jmp 0x4e45
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x35d8
jmp 0x4e48
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x35d8
movq %rsp, %rdi
callq 0x556a
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O2/gasparfm[P]anapache/anapacheapp.cpp
// Function: AnapacheApp::readLogData(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, bool, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
std::string AnapacheApp::readLogData(std::string::iterator& it, bool quotes, std::string::iterator strEnd)
{
  std::string out = "";
  bool brackets = false;
  int k = 0;

  if (*it=='[')
    {
      brackets=true;
      it++;
    }
  else if ( (*it == '-') && (!quotes) )
    {
      /* Information not available - */
      it++;
      return "-";
    }
  do
    {
      if ( it == strEnd)
	throw AnaException("Unexpected end of line");
      if ( (*it==']') && (brackets) )
	{
	  ++it;
	  return out;
	}
      else if ( (*it=='"') && (quotes) )
	  return out;
      else if ( (*it==' ') && (!quotes) && (!brackets) )
	  return out;
      else
	out+=*it;
      ++it;
    } while (1);
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4517(%rip), %rsi      # 0x9397
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3d2c
movq (%r14), %rax
movb (%rax), %r12b
cmpb $0x5b, %r12b
je 0x4ecb
cmpb $0x2d, %r12b
setne %cl
orb %bpl, %cl
jne 0x4ed1
incq %rax
movq %rax, (%r14)
leaq 0x41c2(%rip), %rsi      # 0x9076
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3d2c
jmp 0x4f60
jmp 0x4fbb
incq %rax
movq %rax, (%r14)
cmpq %r15, %rax
je 0x4f7a
movb (%rax), %cl
cmpb $0x5b, %r12b
jne 0x4ee7
cmpb $0x5d, %cl
je 0x4f18
cmpb $0x22, %cl
setne %al
movl %ebp, %edx
xorb $0x1, %dl
orb %al, %dl
je 0x4f1e
cmpb $0x5b, %r12b
je 0x4f06
cmpb $0x20, %cl
jne 0x4f06
testb %bpl, %bpl
je 0x4f1e
movsbl %cl, %esi
leaq 0x10(%rsp), %rdi
callq 0x32c0
movq (%r14), %rax
jmp 0x4ecb
incq %rax
movq %rax, (%r14)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x4f41
movq %rdx, (%rbx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x4f47
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x31a0
movq %rax, %r14
leaq 0x426f(%rip), %rsi      # 0x91fb
movq %rax, %rdi
xorl %edx, %edx
callq 0x531c
leaq 0x8d43(%rip), %rsi      # 0xdce0
leaq 0x3bc(%rip), %rdx       # 0x5360
movq %r14, %rdi
callq 0x3520
jmp 0x4fbb
movq %rax, %rbx
movq %r14, %rdi
callq 0x3250
jmp 0x4fbe
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %edi, %edi
callq 0x3310
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x30(%rsp), %rsi
callq 0x31d0
leaq 0x41aa(%rip), %rsi      # 0x9245
movq %rbx, %rdi
callq 0x54fc
testb %al, %al
je 0x50ae
movq 0x8(%rsp), %rbx
jmp 0x512d
leaq 0x4194(%rip), %rsi      # 0x9249
movq %rbx, %rdi
callq 0x54fc
testb %al, %al
je 0x50cf
movq $-0x15180, %rbx         # imm = 0xFFFEAE80
addq 0x8(%rsp), %rbx
jmp 0x512d
pushq $0x2f
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3440
cmpq $-0x1, %rax
leaq 0x4175(%rip), %rax      # 0x925c
leaq 0x4165(%rip), %rsi      # 0x9253
cmoveq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x3590
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdx
callq 0x3070
movq %rax, %r14
movq %rbx, %rdi
callq 0x3200
movq 0x8(%rsp), %rcx
xorq %rax, %rcx
xorl %ebx, %ebx
orq %r14, %rcx
cmovneq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x5261
movq 0x8db0(%rip), %rdi      # 0xdfb0
leaq 0x405e(%rip), %rsi      # 0x9265
callq 0x3330
movq %rax, %r14
leaq 0x403d(%rip), %rsi      # 0x9253
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3d2c
movq 0x28(%rbx), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x715a
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32f0
movq %rax, %rdi
callq 0x3190
leaq 0x8(%rsp), %rdi
callq 0x35d8
leaq 0x48(%rsp), %rdi
callq 0x35d8
cmpq $0x0, 0x30(%rbx)
je 0x52d0
movq 0x8d41(%rip), %rdi      # 0xdfb0
leaq 0x3ff6(%rip), %rsi      # 0x926c
callq 0x3330
movq %rax, %r14
leaq 0x3fce(%rip), %rsi      # 0x9253
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3d2c
movq 0x30(%rbx), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x715a
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32f0
movq %rax, %rdi
callq 0x3190
leaq 0x8(%rsp), %rdi
callq 0x35d8
leaq 0x28(%rsp), %rdi
callq 0x35d8
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x52f6
jmp 0x52e4
movq %rax, %rbx
jmp 0x530a
movq %rax, %rbx
jmp 0x5314
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35d8
leaq 0x28(%rsp), %rdi
jmp 0x530f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35d8
leaq 0x48(%rsp), %rdi
callq 0x35d8
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movb $0x0, 0x4(%r12)
movl $0xa0d0920, (%r12)      # imm = 0xA0D0920
movq (%rsi), %rbx
movq 0x8(%rsi), %rbp
decq %rbp
xorl %r15d, %r15d
cmpq %rbp, %r15
jg 0x5a00
movsbl (%rbx,%r15), %esi
movq %r12, %rdi
callq 0x3140
testq %rax, %rax
je 0x5a00
incq %r15
jmp 0x59e4
cmpq $-0x1, %rbp
pushq $-0x1
popq %r12
cmovlq %rbp, %r12
leaq 0x8(%rsp), %r13
testq %rbp, %rbp
js 0x5a2f
movsbl (%rbx,%rbp), %esi
movq %r13, %rdi
callq 0x3140
testq %rax, %rax
je 0x5a2c
decq %rbp
jmp 0x5a11
movq %rbp, %r12
subq %r15, %r12
incq %r12
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3370
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x2b0(%rdi), %rsi
movq 0x2b0(%rdi), %r8
xorl %ecx, %ecx
xorl %eax, %eax
movq %rax, (%rdx)
movq 0x2b8(%rdi), %r9
cmpq %r9, %rax
jae 0x5a99
cmpb $0x5b, (%r8,%rax)
jne 0x5a99
incq %rax
addq $-0x2, %rcx
jmp 0x5a7a
addq %r9, %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3420
movq %r14, %rdi
callq 0x35d8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x58(%rsp), %rbp
leaq 0x88(%rsp), %rbx
movq %rsi, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x7056
leaq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x3460
movq %r13, %rdi
movq %r12, %rsi
callq 0x3460
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x74c4
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq $0x1
popq %r9
callq 0x7f21
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3420
movq %rbx, %rdi
callq 0x35d8
movq %rbp, %rdi
callq 0x679c
movq %r13, %rdi
callq 0x35d8
movq 0x18(%rsp), %rdi
callq 0x78bc
cmpw $0x1, %ax
je 0x703d
movq %r12, %rdi
callq 0x35d8
jmp 0x6fb6
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x31f0
leaq 0x18(%rsp), %rdi
callq 0x35d8
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7071
movq %rax, %rbx
jmp 0x7083
jmp 0x7071
movq %rax, %rbx
jmp 0x708d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x679c
leaq 0x38(%rsp), %rdi
callq 0x35d8
leaq 0x18(%rsp), %rdi
callq 0x35d8
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
jne 0x7181
xorl %edi, %edi
callq 0x3310
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x31d0
movq (%r15), %r15
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %r12
movl $0x80, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x33b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3290
testq %rax, %rax
jne 0x71e0
movq 0x18(%rsp), %rsi
subq $-0x80, %rsi
movq %r12, %rdi
callq 0x3470
jmp 0x71b3
movq 0x10(%rsp), %rcx
movb $0x0, (%rcx,%rax)
movq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3d2c
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7216
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35d8
movq %rbx, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rdx
leaq 0x21c4(%rip), %rsi      # 0x940e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7410
leaq 0x7132(%rip), %rdi      # 0xe390
movq %r12, %rsi
callq 0x6814
leaq 0x8(%rsp), %rdi
callq 0x54e6
leaq 0x2196(%rip), %rsi      # 0x940d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x744c
leaq 0x7102(%rip), %rdi      # 0xe390
movq %r12, %rsi
callq 0x6814
leaq 0x8(%rsp), %rdi
callq 0x54e6
leaq 0x216c(%rip), %rsi      # 0x9413
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x7410
leaq 0x70d2(%rip), %rdi      # 0xe390
movq %r15, %rsi
callq 0x6814
leaq 0x8(%rsp), %rdi
callq 0x54e6
leaq 0x2141(%rip), %rsi      # 0x9418
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7488
leaq 0x70a2(%rip), %rdi      # 0xe390
movq %r14, %rsi
callq 0x6814
leaq 0x8(%rsp), %rdi
callq 0x54e6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7312
jmp 0x7312
jmp 0x7312
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54e6
movq %rbx, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6ae9(%rip), %rdx      # 0xe320
fldt 0x20(%rsp)
flds 0x1bdf(%rip)            # 0x9420
fxch %st(1)
fucomi %st(1), %st
jbe 0x7855
fmuls 0x1bd7(%rip)            # 0x9424
addq $0x6, %rdx
fxch %st(1)
jmp 0x7841
fstp %st(1)
fstpt (%rsp)
leaq 0x1bc7(%rip), %rsi      # 0x9428
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x19a6(%rip), %rsi      # 0x9225
callq 0x33e0
testq %rax, %rax
je 0x78b1
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3390
movq %rbx, %rdi
callq 0x3030
movq %rax, %r14
movq %rbx, %rdi
callq 0x3340
movq %r14, %rax
jmp 0x78b4
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
xorl %esi, %esi
xorl %eax, %eax
callq 0x3260
cmpl $-0x1, %eax
je 0x78d8
movl %eax, %edi
callq 0x35b0
movw $0x1, %ax
jmp 0x78ea
callq 0x3050
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
setne %al
negl %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
xorl %r15d, %r15d
leaq 0x6a11(%rip), %r12      # 0xe360
movq %rbx, %r13
cmpq $0x1e, %r15
je 0x7975
leaq (%r12,%r15), %rsi
movq %r14, %rdi
callq 0x3480
testl %eax, %eax
je 0x7972
shlq $0xa, %r13
addq $0x3, %r15
jmp 0x7952
movq %r13, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
leaq 0xe(%rsp), %r8
leaq 0x1a9d(%rip), %rsi      # 0x9430
leaq 0x30(%rsp), %rdx
leaq 0xd(%rsp), %rbx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3320
movsbl (%rbx), %edi
callq 0x3570
movb %al, (%rbx)
movsbl 0x1(%rbx), %edi
callq 0x34a0
movb %al, 0x1(%rbx)
movb $0x0, 0x2(%rbx)
fldt 0x30(%rsp)
fstpt 0x24(%rsp)
movq %rbx, %rdi
callq 0x7936
movq %rax, 0x10(%rsp)
fildll 0x10(%rsp)
fldt 0x24(%rsp)
fmulp %st, %st(1)
fnstcw 0x8(%rsp)
movzwl 0x8(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0xa(%rsp)
fldcw 0xa(%rsp)
fistpll 0x18(%rsp)
fldcw 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x69c7(%rip), %rax      # 0xe3d8
testq %rax, %rax
je 0x7a17
retq
pushq %rax
leaq 0x1a19(%rip), %rdi      # 0x9438
callq 0x3410
movq %rax, 0x69ad(%rip)      # 0xe3d8
testq %rax, %rax
jne 0x7a55
callq 0x31b0
movl %eax, %edi
callq 0x33d0
testq %rax, %rax
je 0x7a4e
movq 0x20(%rax), %rax
movq %rax, 0x698c(%rip)      # 0xe3d8
jmp 0x7a55
movq 0x6983(%rip), %rax      # 0xe3d8
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3170
movq %rax, %r12
movq %r14, %rdi
callq 0x3170
movq %rax, %r13
movq (%rbx), %rdi
callq 0x33f0
leaq (%r12,%r13), %rdi
addq $0x2, %rdi
callq 0x3450
movq %rax, (%rbx)
testq %r12, %r12
je 0x7aa7
cmpb $0x2f, -0x1(%r15,%r12)
jne 0x7ab0
leaq 0x1995(%rip), %rsi      # 0x9443
jmp 0x7ab7
leaq 0x1986(%rip), %rsi      # 0x943d
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x30a0
movq (%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
xorl %esi, %esi
xorl %eax, %eax
callq 0x3260
testl %eax, %eax
js 0x7b3c
movl %eax, %ebx
pushq $0x41
popq %rsi
movq %r14, %rdi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x3260
cmpl $-0x1, %eax
je 0x7b41
movl %eax, %r14d
movq %rsp, %r15
pushq $-0x4
popq %rbp
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r15, %rsi
callq 0x3490
testq %rax, %rax
je 0x7b46
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3110
testq %rax, %rax
jns 0x7b13
jmp 0x7b48
pushq $-0x1
popq %rbp
jmp 0x7b57
pushq $-0x2
popq %rbp
jmp 0x7b50
xorl %ebp, %ebp
movl %r14d, %edi
callq 0x35b0
movl %ebx, %edi
callq 0x35b0
movl %ebp, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x78bc
testw %ax, %ax
je 0x7c24
movq %r15, %rdi
callq 0x7874
cmpq $-0x1, %rax
je 0x7c28
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3260
testl %eax, %eax
js 0x7c2c
movl %eax, %r15d
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x7be2
callq 0x33f0
leaq 0x1(%r14), %rdi
callq 0x3450
movq %rax, (%rbx)
movl %r15d, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3490
movq %rax, %r12
movl %r15d, %edi
callq 0x35b0
testl %r12d, %r12d
js 0x7c30
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
cmpq %r14, %r12
jne 0x7c34
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
jmp 0x7c37
pushq $-0x1
jmp 0x7c36
pushq $-0x2
jmp 0x7c36
pushq $-0x3
jmp 0x7c36
pushq $-0x4
jmp 0x7c36
pushq $-0x5
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, (%rsp)
movslq %r8d, %r13
xorl %ebx, %ebx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x35c0
cmpq $-0x1, %rax
je 0x7c98
movq %rax, %r13
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x3130
addq 0x8(%r15), %r13
testl %ebp, %ebp
je 0x7c60
incl %ebx
cmpl %ebp, %ebx
jl 0x7c60
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3430
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2e0cc
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0xca6e
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0xca85
movq %rax, 0x98(%rbx)
movq 0xa8(%rbx), %rax
cmpq %rax, 0xb0(%rbx)
je 0xca9c
movq %rax, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x98(%rdi), %rax
subq 0x90(%rdi), %rax
sarq $0x2, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jae 0xcb20
movq %rdi, %rbx
leaq 0x90(%rdi), %r14
addq $0xa8, %rdi
leaq -0x18(%rbp), %rsi
movl %eax, (%rsi)
callq 0xe0d2
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
addq $0x78, %rbx
shrq $0x2, %rax
leaq -0x14(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0xe0d2
leaq 0x24e65(%rip), %rsi     # 0x31974
movq %rbx, %rdi
callq 0xd89e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x244dd(%rip), %rdi     # 0x31004
leaq 0x244f1(%rip), %rsi     # 0x3101f
leaq 0x244fc(%rip), %rcx     # 0x31031
pushq $0x34
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
xorl %r13d, %r13d
pushq $-0x1
popq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jae 0xd7b9
testb $0x1, (%r12,%r13,4)
jne 0xd7b4
movq %r14, %rdi
callq 0xcaa4
movl (%r12,%r13,4), %esi
movq %r14, %rdi
callq 0xce90
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0xced2
movl %eax, (%r12,%r13,4)
incq %r13
jmp 0xd780
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x58(%rax)
testl %eax, %eax
je 0xd86b
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
leaq -0x50(%rbp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movl %eax, %esi
callq 0xdbc2
movq %r12, %rdi
xorl %esi, %esi
callq 0xdc16
movq %r12, %rdi
movq %r13, %rsi
movq -0x30(%rbp), %rdx
callq 0xdc3c
movq %r15, %rdi
movq %r12, %rsi
callq 0xd3e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdda2
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xddc0
movq %r15, %rdi
callq 0xde58
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23c21(%rip), %rdi     # 0x31493
leaq 0x237a6(%rip), %rsi     # 0x3101f
leaq 0x23c28(%rip), %rcx     # 0x314a8
movl $0x165, %edx            # imm = 0x165
callq 0xc180
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xde58
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0xb0(%rdi), %rsi
subq 0xa8(%rdi), %rsi
je 0xd92b
movq %rdi, %rbx
sarq $0x2, %rsi
decq %rsi
callq 0xd994
testq %rax, %rax
je 0xd944
movq 0xb0(%rbx), %rax
movl -0x4(%rax), %esi
movq %rbx, %rdi
callq 0xda06
cmpq $0x1, %rax
jne 0xd95d
movq 0xb0(%rbx), %rax
movl -0x4(%rax), %eax
movq 0x78(%rbx), %rcx
movq 0x90(%rbx), %rdx
movl (%rdx,%rax,4), %eax
cmpl $0x2, (%rcx,%rax,4)
jae 0xd976
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23be6(%rip), %rdi     # 0x31518
leaq 0x236e6(%rip), %rsi     # 0x3101f
leaq 0x23bee(%rip), %rcx     # 0x3152e
pushq $0x16
jmp 0xd98d
leaq 0x23c17(%rip), %rdi     # 0x31562
leaq 0x236cd(%rip), %rsi     # 0x3101f
leaq 0x23bd5(%rip), %rcx     # 0x3152e
pushq $0x17
jmp 0xd98d
leaq 0x23c25(%rip), %rdi     # 0x31589
leaq 0x236b4(%rip), %rsi     # 0x3101f
leaq 0x23bbc(%rip), %rcx     # 0x3152e
pushq $0x18
jmp 0xd98d
leaq 0x23c42(%rip), %rdi     # 0x315bf
leaq 0x2369b(%rip), %rsi     # 0x3101f
leaq 0x23ba3(%rip), %rcx     # 0x3152e
pushq $0x19
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::last_equation_remove_term_(unsigned long)
void Anf::last_equation_remove_term_(const size_t term_index) {
        is_incomplete_last_equation_();
        assert(equations_[equations_.size() - 1] <= term_index && term_index < terms_.size());
        const size_t term_symbols_size = symbols_size_(term_index);
        // remove symbols
        symbols_.erase(symbols_.begin() + terms_[term_index],
                       symbols_.begin() + terms_[term_index] + term_symbols_size);
        // remove the term
        terms_.erase(terms_.begin() + term_index);
        // reindex remaining terms if any
        for (auto i = term_index; i < terms_.size(); i++) {
            terms_[i] -= term_symbols_size;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd8c4
movq 0xb0(%r14), %rax
movl -0x4(%rax), %eax
cmpq %rbx, %rax
ja 0xdb0b
movq 0x98(%r14), %rax
subq 0x90(%r14), %rax
sarq $0x2, %rax
cmpq %rbx, %rax
jbe 0xdb0b
leaq 0x90(%r14), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda06
movq %rax, %r15
leaq 0x78(%r14), %rdi
movq 0x90(%r14), %rax
leaq (,%rbx,4), %r13
movl (%rax,%rbx,4), %esi
shlq $0x2, %rsi
addq 0x78(%r14), %rsi
leaq (%rsi,%r15,4), %rdx
callq 0xdef6
addq 0x90(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xdf00
movq 0x90(%r14), %rax
movq 0x98(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rbx
jae 0xdafc
subl %r15d, (%rax,%rbx,4)
incq %rbx
jmp 0xdaee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23b65(%rip), %rdi     # 0x31677
leaq 0x23506(%rip), %rsi     # 0x3101f
leaq 0x23ba5(%rip), %rcx     # 0x316c5
pushq $0x26
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xd8c4
leaq 0xa8(%rbx), %r14
movq 0xb0(%rbx), %rax
movl -0x4(%rax), %r15d
leaq 0x78(%rbx), %rdi
leaq 0x90(%rbx), %r12
movq 0x80(%rbx), %rdx
movq 0x90(%rbx), %rax
movl (%rax,%r15,4), %esi
shlq $0x2, %r15
shlq $0x2, %rsi
addq 0x78(%rbx), %rsi
callq 0xdef6
addq 0x90(%rbx), %r15
movq 0x98(%rbx), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xdef6
movq 0xb0(%rbx), %rsi
addq $-0x4, %rsi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xdf00
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray::assign_template_into(bal::VariablesArray const&, bal::VariablesArray&) const
inline void assign_template_into(const VariablesArray& template_, VariablesArray& value) const {
            assert(template_.size_ == value.size_);
            const literalid_t* src = template_.data_;
            literalid_t* dst = value.data_;
            const literalid_t* dst_end = value.data_ + value.size_;
            while (dst < dst_end) {
                if (literal_t__is_variable(*src)) {
                    assert(literal_t__variable_id(*src) < size_);
                    *dst = literal_t__lookup(data_, *src);
                } else {
                    *dst = *src;
                };
                src++;
                dst++;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %r8d
cmpl 0x8(%rdx), %r8d
jne 0xde39
movq (%rsi), %rax
movq (%rdx), %rcx
leaq (%rcx,%r8,4), %rdx
movq (%rdi), %rsi
cmpq %rdx, %rcx
jae 0xde18
movl (%rax), %r8d
leal 0x1(%r8), %r9d
cmpl $0x3, %r9d
jb 0xde0b
movl %r8d, %r9d
shrl %r9d
decl %r9d
cmpl 0x8(%rdi), %r9d
jae 0xde1a
movl %r9d, %r9d
andl $0x1, %r8d
xorl (%rsi,%r9,4), %r8d
xorl $0x1, %r8d
movl %r8d, (%rcx)
addq $0x4, %rax
addq $0x4, %rcx
jmp 0xdddb
popq %rbp
retq
leaq 0x23b11(%rip), %rdi     # 0x31932
leaq 0x23904(%rip), %rsi     # 0x3172c
leaq 0x23aa4(%rip), %rcx     # 0x318d3
movl $0xcb, %edx
callq 0xc180
leaq 0x239f6(%rip), %rdi     # 0x31836
leaq 0x238e5(%rip), %rsi     # 0x3172c
leaq 0x23a85(%rip), %rcx     # 0x318d3
movl $0xc5, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/container.hpp
// Function: bal::Container<unsigned int>::resize_(unsigned int)
inline void resize_(const container_size_t size) {
            if (allocated_size_ != size) {
                if (data_ != nullptr) {
                    if (size == 0) {
                        free(data_);
                        data_ = nullptr;
                        size_ = 0;
                    } else {
                        void* new_data = realloc(data_, size * sizeof(T));
                        assert(new_data != nullptr);
                        data_ = (T*)new_data;
                    };
                } else if (size != 0) {
                    data_ = (T*)malloc(size * sizeof(T));
                    assert(data_ != nullptr);
                    size_ = 0;
                } else {
                    size_ = 0;
                };
                allocated_size_ = size;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl %esi, 0x18(%rdi)
je 0xe044
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xe002
testl %ebx, %ebx
je 0xe032
movl %ebx, %esi
shlq $0x2, %rsi
callq 0xc460
testq %rax, %rax
je 0xe049
movq %rax, (%r14)
jmp 0xe040
testl %ebx, %ebx
je 0xe03b
movl %ebx, %edi
shlq $0x2, %rdi
callq 0xc350
movq %rax, (%r14)
testq %rax, %rax
jne 0xe03b
leaq 0x23805(%rip), %rdi     # 0x31825
leaq 0x23790(%rip), %rsi     # 0x317b7
leaq 0x237a1(%rip), %rcx     # 0x317cf
pushq $0x38
jmp 0xe060
callq 0xc310
andq $0x0, (%r14)
andl $0x0, 0x8(%r14)
movl %ebx, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23753(%rip), %rdi     # 0x317a3
leaq 0x23760(%rip), %rsi     # 0x317b7
leaq 0x23771(%rip), %rcx     # 0x317cf
pushq $0x33
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::eor(bal::Anf*, unsigned int, unsigned int const*, unsigned long)
void eor(Anf* const formula, const literalid_t r, const literalid_t args[], const std::size_t args_size) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        for (auto i = 0; i < args_size; i++) {
            _assert_level_0(literal_t__is_variable(args[i]));
            formula->append_equation_term(args[i]);
        };
        formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe396
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xe3af
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
callq 0xcaa4
xorl %r13d, %r13d
cmpq %r13, %r15
je 0xe359
movl (%r12,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x2, %eax
jbe 0xe379
movq %r14, %rdi
callq 0xce90
incq %r13
jmp 0xe33b
xorl %edx, %edx
cmpl $-0x1, %ebx
sete %dl
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x236de(%rip), %rdi     # 0x31a5e
leaq 0x235fc(%rip), %rsi     # 0x31983
leaq 0x2360f(%rip), %rcx     # 0x3199d
pushq $0x13
popq %rdx
callq 0xc180
leaq 0x2e56c(%rip), %rdi     # 0x3c909
leaq 0x235df(%rip), %rsi     # 0x31983
leaq 0x235f2(%rip), %rcx     # 0x3199d
pushq $0xf
jmp 0xe390
leaq 0x2363c(%rip), %rdi     # 0x319f2
leaq 0x235c6(%rip), %rsi     # 0x31983
leaq 0x235d9(%rip), %rcx     # 0x3199d
pushq $0x10
jmp 0xe390
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::con2(bal::Anf*, unsigned int, unsigned int, unsigned int)
void con2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe423
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xe43c
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xcaa4
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xceb0
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x2e4df(%rip), %rdi     # 0x3c909
leaq 0x23552(%rip), %rsi     # 0x31983
leaq 0x23672(%rip), %rcx     # 0x31aaa
pushq $0x1a
jmp 0xe453
leaq 0x235af(%rip), %rdi     # 0x319f2
leaq 0x23539(%rip), %rsi     # 0x31983
leaq 0x23659(%rip), %rcx     # 0x31aaa
pushq $0x1b
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::dis2(bal::Anf*, unsigned int, unsigned int, unsigned int)
void dis2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x);
        formula->append_equation_term(y);
        formula->append_equation_term(x, y);
        formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe4ca
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xe4e3
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xcaa4
movq %r14, %rdi
movl %r12d, %esi
callq 0xce90
movq %r14, %rdi
movl %r15d, %esi
callq 0xce90
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xceb0
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x2e438(%rip), %rdi     # 0x3c909
leaq 0x234ab(%rip), %rsi     # 0x31983
leaq 0x2361f(%rip), %rcx     # 0x31afe
pushq $0x23
jmp 0xe4fa
leaq 0x23508(%rip), %rdi     # 0x319f2
leaq 0x23492(%rip), %rsi     # 0x31983
leaq 0x23606(%rip), %rcx     # 0x31afe
pushq $0x24
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::maj(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int)
void maj(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        formula->append_equation_term(x, z);
        formula->append_equation_term(y, z);
        formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe57f
movl %esi, %ebx
movl %r8d, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0xe598
movl %ecx, %r12d
movl %edx, %r15d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xcaa4
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xceb0
movq %r14, %rdi
movl %r15d, %esi
movl -0x2c(%rbp), %r15d
movl %r15d, %edx
callq 0xceb0
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xceb0
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x2e383(%rip), %rdi     # 0x3c909
leaq 0x233f6(%rip), %rsi     # 0x31983
leaq 0x235be(%rip), %rcx     # 0x31b52
pushq $0x2e
jmp 0xe5af
leaq 0x23453(%rip), %rdi     # 0x319f2
leaq 0x233dd(%rip), %rsi     # 0x31983
leaq 0x235a5(%rip), %rcx     # 0x31b52
pushq $0x2f
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::ch(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int)
void ch(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        formula->append_equation_term(x, z);
        formula->append_equation_term(z);
        formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe62c
movl %esi, %ebx
movl %ecx, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0xe645
movl %r8d, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xcaa4
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %edx
callq 0xceb0
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xceb0
movq %r14, %rdi
movl %r15d, %esi
callq 0xce90
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x2e2d6(%rip), %rdi     # 0x3c909
leaq 0x23349(%rip), %rsi     # 0x31983
leaq 0x23577(%rip), %rcx     # 0x31bb8
pushq $0x39
jmp 0xe65c
leaq 0x233a6(%rip), %rdi     # 0x319f2
leaq 0x23330(%rip), %rsi     # 0x31983
leaq 0x2355e(%rip), %rcx     # 0x31bb8
pushq $0x3a
popq %rdx
callq 0xc180