LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x5f96
movq 0x80d6(%rip), %rdi      # 0xdfb8
leaq 0x4392(%rip), %rsi      # 0xa27b
movl $0x6, %edx
callq 0x33f0
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4366(%rip), %rsi      # 0xa269
leaq 0x4370(%rip), %rdx      # 0xa27a
leaq 0x40(%rsp), %rdi
callq 0x4074
movq 0x28(%rbx), %rdx
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x84f2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x8083(%rip), %rdi      # 0xdfb8
callq 0x33f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3340
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x5f96
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3390
cmpq $0x0, 0x30(%rbx)
je 0x605c
movq 0x8010(%rip), %rdi      # 0xdfb8
leaq 0x42d3(%rip), %rsi      # 0xa282
movl $0x4, %edx
callq 0x33f0
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x42a0(%rip), %rsi      # 0xa269
leaq 0x42aa(%rip), %rdx      # 0xa27a
leaq 0x20(%rsp), %rdi
callq 0x4074
movq 0x30(%rbx), %rdx
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x84f2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x7fbd(%rip), %rdi      # 0xdfb8
callq 0x33f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6045
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x605c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3390
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x6095
jmp 0x6072
movq %rax, %rbx
jmp 0x60c4
movq %rax, %rbx
jmp 0x60db
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6095
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x60db
movq 0x30(%rsp), %rsi
jmp 0x60d3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x60db
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq (%rsi), %r14
cmpq %rsi, %r14
je 0x839e
movq %rsi, %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x78(%rsp), %rbp
leaq 0x58(%rsp), %rbx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x7998
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x7998
movq %rbp, %rdi
movq 0x50(%rsp), %rsi
callq 0x8a78
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x96a5
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3460
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x8315
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbp, %rdi
callq 0x793c
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x8339
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x8(%rsp), %rdi
callq 0x8e19
cmpw $0x1, %ax
je 0x8373
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8365
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
movq (%r14), %r14
cmpq %r15, %r14
jne 0x828c
jmp 0x839e
leaq 0x8(%rsp), %rsi
movq 0x48(%rsp), %rdi
callq 0x3210
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x839e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83c3
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x793c
jmp 0x83cb
jmp 0x83c3
movq %rax, %rbx
jmp 0x83e7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x83e7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8403
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
jne 0x851b
xorl %edi, %edi
callq 0x3330
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %r14
movq %r14, %rsi
callq 0x31f0
movq (%r15), %r15
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x18(%rsp), %r12
movl $0x80, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x3400
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x32c0
testq %rax, %rax
jne 0x857c
movq 0x20(%rsp), %rsi
subq $-0x80, %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x3110
jmp 0x854d
movq 0x18(%rsp), %rcx
movb $0x0, (%rcx,%rax)
movq 0x18(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x402c
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x85ae
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x85c1
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x85db
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rdx
leaq 0x1e36(%rip), %rsi      # 0xa43b
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x8916
leaq 0x5d87(%rip), %rdi      # 0xe3a0
movq %r12, %rsi
callq 0x7a56
leaq 0x38(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x863c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x8657
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0x1ddc(%rip), %rsi      # 0xa43a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x898c
leaq 0x5d2b(%rip), %rdi      # 0xe3a0
movq %r12, %rsi
callq 0x7a56
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x8694
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x86ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0x1d8e(%rip), %rsi      # 0xa440
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x8916
leaq 0x5cd7(%rip), %rdi      # 0xe3a0
movq %r15, %rsi
callq 0x7a56
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x86e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x86ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
leaq 0x1d3f(%rip), %rsi      # 0xa445
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a02
leaq 0x5c83(%rip), %rdi      # 0xe3a0
movq %r14, %rsi
callq 0x7a56
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x873c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3390
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8753
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8768
jmp 0x8768
jmp 0x8768
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x88e0
movq %rbx, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
fldt 0x20(%rsp)
flds 0x16d2(%rip)            # 0xa450
fxch %st(1)
fucomi %st(1), %st
jbe 0x8d95
xorl %eax, %eax
fmuls 0x16c8(%rip)            # 0xa454
incq %rax
fucomi %st(1), %st
ja 0x8d86
jmp 0x8d9d
fstp %st(1)
xorl %eax, %eax
fldz
fxch %st(1)
fstp %st(1)
leaq (%rax,%rax,2), %rax
leaq 0x5586(%rip), %rcx      # 0xe330
leaq (%rcx,%rax,2), %rdx
fstpt (%rsp)
leaq 0x16a0(%rip), %rsi      # 0xa458
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30b0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1465(%rip), %rsi      # 0xa23b
callq 0x3420
testq %rax, %rax
je 0x8e0a
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33c0
movq %rbx, %rdi
callq 0x3030
movq %rax, %r14
movq %rbx, %rdi
callq 0x3370
movq %r14, %rax
jmp 0x8e11
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3290
cmpl $-0x1, %eax
je 0x8e35
movl %eax, %edi
callq 0x35f0
movw $0x1, %ax
jmp 0x8e47
callq 0x3060
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
setne %al
negl %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xe(%rsp), %r8
leaq 0x1568(%rip), %rsi      # 0xa460
xorl %r14d, %r14d
leaq 0x30(%rsp), %rdx
leaq 0xd(%rsp), %rbx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3350
movsbl (%rbx), %edi
callq 0x35e0
movb %al, (%rbx)
movsbl 0x1(%rbx), %edi
callq 0x34b0
movb %al, 0x1(%rbx)
movb $0x0, 0x2(%rbx)
movl $0x1, %r15d
fldt 0x30(%rsp)
fstpt 0x24(%rsp)
leaq 0x5432(%rip), %r12      # 0xe370
leaq (%r12,%r14), %rsi
movq %rbx, %rdi
callq 0x3490
testl %eax, %eax
je 0x8f62
shlq $0xa, %r15
addq $0x3, %r14
cmpq $0x1e, %r14
jne 0x8f3e
movl $0x1, %r15d
movq %r15, 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 $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
cmpq $0x0, 0x543e(%rip)      # 0xe3e8
jne 0x8fbf
leaq 0x14b5(%rip), %rdi      # 0xa468
callq 0x3450
movq %rax, 0x5429(%rip)      # 0xe3e8
cmpq $0x0, 0x5421(%rip)      # 0xe3e8
jne 0x8fe5
callq 0x31d0
movl %eax, %edi
callq 0x3410
testq %rax, %rax
je 0x8fe5
movq 0x20(%rax), %rax
movq %rax, 0x5403(%rip)      # 0xe3e8
movq 0x53fc(%rip), %rax      # 0xe3e8
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3190
movq %rax, %r12
movq %r14, %rdi
callq 0x3190
movq %rax, %r13
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x902a
callq 0x3430
movq $0x0, (%rbx)
leaq (%r12,%r13), %rdi
addq $0x2, %rdi
callq 0x3480
movq %rax, (%rbx)
testq %r12, %r12
je 0x9047
cmpb $0x2f, -0x1(%r15,%r12)
jne 0x9050
leaq 0x1425(%rip), %rsi      # 0xa473
jmp 0x9057
leaq 0x1416(%rip), %rsi      # 0xa46d
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x30b0
movq (%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
xorl %esi, %esi
xorl %eax, %eax
callq 0x3290
testl %eax, %eax
js 0x90dd
movl %eax, %ebx
movq %r14, %rdi
movl $0x41, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x3290
cmpl $-0x1, %eax
je 0x90e5
movl %eax, %ebp
movq %rsp, %r14
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
callq 0x34a0
testq %rax, %rax
je 0x90ed
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3140
testq %rax, %rax
jns 0x90af
movl $0xfffffffc, %r14d      # imm = 0xFFFFFFFC
jmp 0x90f0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x90fe
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x90f7
xorl %r14d, %r14d
movl %ebp, %edi
callq 0x35f0
movl %ebx, %edi
callq 0x35f0
movl %r14d, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8e19
testw %ax, %ax
je 0x91e4
movq %r12, %rdi
callq 0x8dcb
cmpq $-0x1, %rax
je 0x91eb
movq %rax, %r14
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3290
testl %eax, %eax
js 0x91f2
movl %eax, %ebp
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0x919a
callq 0x3430
movq $0x0, (%rbx)
leaq 0x1(%r14), %rdi
callq 0x3480
movq %rax, (%rbx)
movl %ebp, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x34a0
movq %rax, %r15
movl %ebp, %edi
callq 0x35f0
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %r15d, %r15d
js 0x91f7
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
cmpq %r14, %r15
jne 0x91f7
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
jmp 0x91f7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x91f7
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x91f7
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movslq %r8d, %r13
cmpl $0x2, %r9d
movl $0x1, %eax
cmovgel %r9d, %eax
movl %eax, 0xc(%rsp)
xorl %r14d, %r14d
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3580
cmpq $-0x1, %rax
je 0x927c
movq %rax, %r13
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33d0
addq 0x8(%r15), %r13
testl %ebp, %ebp
je 0x9236
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x9236
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rsi
cmpq %rsi, %rdx
je 0x92a0
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x92a6
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ce6c
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0xe28e
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0xe2a5
movq %rax, 0x98(%rbx)
movq 0xa8(%rbx), %rax
cmpq %rax, 0xb0(%rbx)
je 0xe2bc
movq %rax, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq 0x98(%rdi), %rax
subq 0x90(%rdi), %rax
sarq $0x2, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jae 0xe39d
movq %rdi, %rbx
movl %eax, -0x10(%rbp)
movq 0xb0(%rdi), %rsi
cmpq 0xb8(%rdi), %rsi
je 0xe30f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%rbx)
jmp 0xe31f
leaq 0xa8(%rbx), %rdi
leaq -0x10(%rbp), %rdx
callq 0xfb44
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
shrq $0x2, %rax
movl %eax, -0xc(%rbp)
movq 0x98(%rbx), %rsi
cmpq 0xa0(%rbx), %rsi
je 0xe350
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%rbx)
jmp 0xe360
leaq 0x90(%rbx), %rdi
leaq -0xc(%rbp), %rdx
callq 0xfb44
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0xe383
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x80(%rbx)
jmp 0xe396
addq $0x78, %rbx
leaq 0x335e6(%rip), %rdx     # 0x41974
movq %rbx, %rdi
callq 0xfc7c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x32c60(%rip), %rdi     # 0x41004
leaq 0x32c74(%rip), %rsi     # 0x4101f
leaq 0x32c7f(%rip), %rcx     # 0x41031
movl $0x34, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x8(%rsi)
je 0xf328
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
leaq -0x2c(%rbp), %r15
testb $0x1, (%r12,%r13,4)
jne 0xf30f
movq %r14, %rdi
callq 0xe2c4
movl (%r12,%r13,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe3bc
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0xe836
movl %eax, (%r12,%r13,4)
incq %r13
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jb 0xf2d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x50(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x58(%rax)
testl %eax, %eax
je 0xf48f
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0xf76c
cmpl $0x0, 0x8(%r12)
je 0xf39c
movl $0x3, %eax
movq -0x48(%rbp), %rcx
xorl %edx, %edx
movl %eax, (%rcx,%rdx,4)
incq %rdx
movl -0x40(%rbp), %esi
addl $0x2, %eax
cmpq %rsi, %rdx
jb 0xf38b
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq -0x50(%rbp), %rdx
callq 0xf7c2
movq %r15, %rdi
movq %r12, %rsi
callq 0xee82
movq $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfa68
movl 0x1c(%r14), %eax
movl %eax, 0x1c(%rbx)
movl 0x8(%rbx), %ecx
cmpl %ecx, 0x8(%r14)
jne 0xf4ae
testq %rcx, %rcx
je 0xf43a
movq (%rbx), %rax
leaq (%rax,%rcx,4), %rcx
movq (%r14), %rdx
movq -0x48(%rbp), %rsi
movl (%rdx), %edi
leal 0x1(%rdi), %r8d
cmpl $0x3, %r8d
jb 0xf42b
movl %edi, %r8d
shrl %r8d
decl %r8d
cmpl -0x40(%rbp), %r8d
jae 0xf470
movl %r8d, %r8d
andl $0x1, %edi
xorl (%rsi,%r8,4), %edi
xorl $0x1, %edi
movl %edi, (%rax)
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rcx, %rax
jb 0xf403
cmpl $0x0, -0x30(%rbp)
je 0xf45e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xf456
callq 0xc350
movq $0x0, -0x48(%rbp)
xorl %eax, %eax
movl %eax, -0x40(%rbp)
movl %eax, -0x30(%rbp)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x324bb(%rip), %rdi     # 0x41932
leaq 0x322ae(%rip), %rsi     # 0x4172c
leaq 0x3244e(%rip), %rcx     # 0x418d3
movl $0xcb, %edx
callq 0xc180
leaq 0x31ffd(%rip), %rdi     # 0x41493
leaq 0x31b82(%rip), %rsi     # 0x4101f
leaq 0x32004(%rip), %rcx     # 0x414a8
movl $0x165, %edx            # imm = 0x165
callq 0xc180
leaq 0x32381(%rip), %rdi     # 0x41836
leaq 0x32270(%rip), %rsi     # 0x4172c
leaq 0x32410(%rip), %rcx     # 0x418d3
movl $0xc5, %edx
callq 0xc180
movq %rax, %rbx
cmpl $0x0, -0x30(%rbp)
je 0xf4f4
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xf4ec
callq 0xc350
movq $0x0, -0x48(%rbp)
xorl %eax, %eax
movl %eax, -0x40(%rbp)
movl %eax, -0x30(%rbp)
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0xa8(%rdi), %rax
movq 0xb0(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0xf58d
sarq $0x2, %rcx
cmpq %rdx, 0xb0(%rdi)
je 0xf528
movl (%rax,%rcx,4), %edx
jmp 0xf53a
movq 0x98(%rdi), %rdx
subq 0x90(%rdi), %rdx
sarq $0x2, %rdx
movl -0x4(%rax,%rcx,4), %eax
cmpq %rax, %rdx
je 0xf5ac
movq 0x90(%rdi), %rcx
movq 0x98(%rdi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
decq %rdx
cmpq %rax, %rdx
jne 0xf571
movq 0x80(%rdi), %rdx
subq 0x78(%rdi), %rdx
sarq $0x2, %rdx
jmp 0xf575
movl 0x4(%rcx,%rax,4), %edx
movl (%rcx,%rax,4), %eax
subq %rax, %rdx
cmpq $0x1, %rdx
jne 0xf5cb
movq 0x78(%rdi), %rcx
cmpl $0x2, (%rcx,%rax,4)
jae 0xf5ea
popq %rbp
retq
leaq 0x31f84(%rip), %rdi     # 0x41518
leaq 0x31a84(%rip), %rsi     # 0x4101f
leaq 0x31f8c(%rip), %rcx     # 0x4152e
movl $0x16, %edx
callq 0xc180
leaq 0x31faf(%rip), %rdi     # 0x41562
leaq 0x31a65(%rip), %rsi     # 0x4101f
leaq 0x31f6d(%rip), %rcx     # 0x4152e
movl $0x17, %edx
callq 0xc180
leaq 0x31fb7(%rip), %rdi     # 0x41589
leaq 0x31a46(%rip), %rsi     # 0x4101f
leaq 0x31f4e(%rip), %rcx     # 0x4152e
movl $0x18, %edx
callq 0xc180
leaq 0x31fce(%rip), %rdi     # 0x415bf
leaq 0x31a27(%rip), %rsi     # 0x4101f
leaq 0x31f2f(%rip), %rcx     # 0x4152e
movl $0x19, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf4fc
movq 0xb0(%r14), %rax
movl -0x4(%rax), %eax
cmpq %rbx, %rax
ja 0xf73b
movq 0x90(%r14), %rax
movq 0x98(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0xf73b
movq 0x98(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
decq %rcx
cmpq %rbx, %rcx
jne 0xf67b
movq 0x80(%r14), %r12
subq 0x78(%r14), %r12
sarq $0x2, %r12
jmp 0xf680
movl 0x4(%rax,%rbx,4), %r12d
movl (%rax,%rbx,4), %r13d
cmpq %r13, %r12
je 0xf6d1
movq 0x78(%r14), %rax
leaq (%rax,%r13,4), %r15
leaq (%rax,%r12,4), %rsi
movq 0x80(%r14), %rdx
subq %rsi, %rdx
je 0xf6b5
movq %r15, %rdi
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xc450
movq -0x30(%rbp), %rsi
movq 0x80(%r14), %rax
movq %rax, %rcx
subq %rsi, %rcx
addq %rcx, %r15
cmpq %r15, %rax
je 0xf6d1
movq %r15, 0x80(%r14)
movq 0x90(%r14), %rax
movq 0x98(%r14), %rdx
leaq (%rax,%rbx,4), %rsi
addq $0x4, %rsi
cmpq %rdx, %rsi
je 0xf6f8
leaq (%rax,%rbx,4), %rdi
subq %rsi, %rdx
callq 0xc450
movq 0x90(%r14), %rax
movq 0x98(%r14), %rcx
addq $-0x4, %rcx
movq %rcx, 0x98(%r14)
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0xf72c
subl %r12d, %r13d
addl %r13d, (%rax,%rbx,4)
incq %rbx
cmpq %rbx, %rcx
jne 0xf720
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31f35(%rip), %rdi     # 0x41677
leaq 0x318d6(%rip), %rsi     # 0x4101f
leaq 0x31f75(%rip), %rcx     # 0x416c5
movl $0x26, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfddf
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xfdfe
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
callq 0xe2c4
testq %r15, %r15
je 0xfda0
xorl %r13d, %r13d
movl (%r12,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x2, %eax
jbe 0xfdc0
movq %r14, %rdi
callq 0xe7f0
incq %r13
cmpq %r13, %r15
jne 0xfd84
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 0xe836
leaq 0x31c97(%rip), %rdi     # 0x41a5e
leaq 0x31bb5(%rip), %rsi     # 0x41983
leaq 0x31bc8(%rip), %rcx     # 0x4199d
movl $0x13, %edx
callq 0xc180
leaq 0x3ca1a(%rip), %rdi     # 0x4c800
leaq 0x31b96(%rip), %rsi     # 0x41983
leaq 0x31ba9(%rip), %rcx     # 0x4199d
movl $0xf, %edx
callq 0xc180
leaq 0x31bed(%rip), %rdi     # 0x419f2
leaq 0x31b77(%rip), %rsi     # 0x41983
leaq 0x31b8a(%rip), %rcx     # 0x4199d
movl $0x10, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfe78
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xfe97
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xe2c4
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xe812
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 0xe836
leaq 0x3c981(%rip), %rdi     # 0x4c800
leaq 0x31afd(%rip), %rsi     # 0x41983
leaq 0x31c1d(%rip), %rcx     # 0x41aaa
movl $0x1a, %edx
callq 0xc180
leaq 0x31b54(%rip), %rdi     # 0x419f2
leaq 0x31ade(%rip), %rsi     # 0x41983
leaq 0x31bfe(%rip), %rcx     # 0x41aaa
movl $0x1b, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0xff27
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xff46
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xe2c4
movq %r14, %rdi
movl %r12d, %esi
callq 0xe7f0
movq %r14, %rdi
movl %r15d, %esi
callq 0xe7f0
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xe812
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 0xe836
leaq 0x3c8d2(%rip), %rdi     # 0x4c800
leaq 0x31a4e(%rip), %rsi     # 0x41983
leaq 0x31bc2(%rip), %rcx     # 0x41afe
movl $0x23, %edx
callq 0xc180
leaq 0x31aa5(%rip), %rdi     # 0x419f2
leaq 0x31a2f(%rip), %rsi     # 0x41983
leaq 0x31ba3(%rip), %rcx     # 0x41afe
movl $0x24, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0xffe8
movl %esi, %ebx
movl %r8d, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0x10007
movl %ecx, %r12d
movl %edx, %r15d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xe2c4
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xe812
movq %r14, %rdi
movl %r15d, %esi
movl -0x2c(%rbp), %r15d
movl %r15d, %edx
callq 0xe812
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xe812
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 0xe836
leaq 0x3c811(%rip), %rdi     # 0x4c800
leaq 0x3198d(%rip), %rsi     # 0x41983
leaq 0x31b55(%rip), %rcx     # 0x41b52
movl $0x2e, %edx
callq 0xc180
leaq 0x319e4(%rip), %rdi     # 0x419f2
leaq 0x3196e(%rip), %rsi     # 0x41983
leaq 0x31b36(%rip), %rcx     # 0x41b52
movl $0x2f, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1009d
movl %esi, %ebx
movl %ecx, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0x100bc
movl %r8d, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xe2c4
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %edx
callq 0xe812
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xe812
movq %r14, %rdi
movl %r15d, %esi
callq 0xe7f0
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 0xe836
leaq 0x3c75c(%rip), %rdi     # 0x4c800
leaq 0x318d8(%rip), %rsi     # 0x41983
leaq 0x31b06(%rip), %rcx     # 0x41bb8
movl $0x39, %edx
callq 0xc180
leaq 0x3192f(%rip), %rdi     # 0x419f2
leaq 0x318b9(%rip), %rsi     # 0x41983
leaq 0x31ae7(%rip), %rcx     # 0x41bb8
movl $0x3a, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::__add2(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
literalid_t __add2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y,
                       const literalid_t r_prev, const literalid_t x_prev, const literalid_t y_prev) {
        _assert_level_0(formula != nullptr);
        formula->append_equation();
        formula->append_equation_term(x);
        formula->append_equation_term(y);
        formula->append_equation_term(x_prev);
        formula->append_equation_term(y_prev);
        formula->append_equation_term(x_prev, y_prev);
        formula->append_equation_term(x_prev, r_prev);
        formula->append_equation_term(y_prev, r_prev);
        return 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
movl %r8d, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testq %rdi, %rdi
je 0x101d6
movl %r9d, %r12d
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
movl 0x10(%rbp), %r13d
callq 0xe2c4
movq %r14, %rdi
movl %r15d, %esi
callq 0xe7f0
movq %r14, %rdi
movl %ebx, %esi
callq 0xe7f0
movq %r14, %rdi
movl %r12d, %esi
callq 0xe7f0
movq %r14, %rdi
movl %r13d, %esi
callq 0xe7f0
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0xe812
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %ebx
movl %ebx, %edx
callq 0xe812
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0xe812
xorl %edx, %edx
movl -0x30(%rbp), %esi
cmpl $-0x1, %esi
sete %dl
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe836
leaq 0x3c623(%rip), %rdi     # 0x4c800
leaq 0x3179f(%rip), %rsi     # 0x41983
leaq 0x31abf(%rip), %rcx     # 0x41caa
movl $0x4e, %edx
callq 0xc180
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__statistics_reset()
void __statistics_reset() {
        __find_clause_found = 0;
        __find_clause_unfound = 0;
        __compare_clauses_ = 0;
        __append_clause_ = 0;
        __time_start_ = std::chrono::system_clock::now();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, 0x4f0e8(%rip)     # 0x5f2ec
movl %eax, 0x4f0e6(%rip)     # 0x5f2f0
movl %eax, 0x4f0e4(%rip)     # 0x5f2f4
movl %eax, 0x4f0e2(%rip)     # 0x5f2f8
callq 0xc050
movq %rax, 0x4f0de(%rip)     # 0x5f300
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__print_clause(unsigned int const*)
bool __print_clause(const uint32_t* const p_clause) {
        std::cout << (_clause_is_included(p_clause) ? "i" : "e") << ": ";
        print_clause(std::cout, p_clause, "; ");
        std::cout << std::endl;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpw $0x0, (%rdi)
leaq 0x31a0d(%rip), %rax     # 0x41d70
leaq 0x377d4(%rip), %rsi     # 0x47b3e
cmovnsq %rax, %rsi
movq 0x4ec33(%rip), %rbx     # 0x5efa8
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc320
leaq 0x38030(%rip), %rsi     # 0x483b9
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc320
leaq 0x319d5(%rip), %rdx     # 0x41d72
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1057f
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__print_conflict(unsigned int const*, unsigned int const*)
void __print_conflict(const literalid_t variables[], const uint32_t* const p_clause) {
        std::cout << "CONFLICT" << std::endl;
        std::cout << "Clause(s):" << std::endl;
        __print_clause(p_clause);
        std::cout << "Variable(s):" << std::endl;
        for (auto i = 0; i < _clause_size(p_clause); i++) {
            const literalid_t literal_id = _clause_literal(p_clause, i);
            const variableid_t variable_id = literal_t__variable_id(literal_id);
            const literalid_t value_id = literal_t::resolve(variables, literal_id);
            std::cout << literal_t(variable_t__literal_id(variable_id)) << " = " << literal_t(value_id) << std::endl;
        };
    }

// 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 0x4ebb7(%rip), %r15     # 0x5efa8
leaq 0x3197d(%rip), %rsi     # 0x41d75
movl $0x8, %edx
movq %r15, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
leaq 0x3194b(%rip), %rsi     # 0x41d7e
movl $0xa, %edx
movq %r15, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
movq %rbx, %rdi
callq 0x1034e
leaq 0x31913(%rip), %rsi     # 0x41d89
movl $0xc, %edx
movq %r15, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
movzwl (%rbx), %eax
testl $0x7fff, %eax           # imm = 0x7FFF
je 0x10570
xorl %r13d, %r13d
movl 0x4(%rbx,%r13,4), %eax
movl %eax, %ecx
leal -0x2(%rcx), %edx
cmpl $-0x4, %edx
ja 0x104f3
movl %ecx, %edx
shrl %edx
decl %edx
movl (%r14,%rdx,4), %edx
movl %ecx, %r15d
andl $0x1, %r15d
xorl %edx, %r15d
xorl $0x1, %r15d
cmpl $-0x1, %edx
cmovel %edx, %r15d
cmpl %ecx, %r15d
movl %r15d, %ecx
jne 0x104c2
jmp 0x104f6
movl %ecx, %r15d
orl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x4eaa5(%rip), %rdi     # 0x5efa8
leaq -0x30(%rbp), %rsi
callq 0x10712
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
leaq 0x31878(%rip), %rsi     # 0x41d96
callq 0xc320
movl %r15d, -0x2c(%rbp)
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x10712
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r12, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
incq %r13
movl (%rbx), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
cmpq %rax, %r13
jb 0x104bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/variables.hpp
// Function: bal::operator<<(std::ostream&, bal::literal_t const&)
std::ostream& operator << (std::ostream& stream, const literal_t& value) {
            if (literal_t__is_variable(value.id_)) {
                if (literal_t__is_negation(value.id_)) {
                    stream << "-";
                };
                stream << std::dec << (literal_t__variable_id(value.id_) + 1);
            } else if (literal_t__is_unassigned(value.id_)) {
                stream << "*";
            } else {
                stream << (literal_t__is_constant_1(value.id_) ? "0b1" : "0b0");
            };
            return stream;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
jae 0x1073f
cmpl $0x1, %eax
leaq 0x3166f(%rip), %rax     # 0x41d9c
leaq 0x3166c(%rip), %rsi     # 0x41da0
cmoveq %rax, %rsi
movl $0x3, %edx
jmp 0x10750
cmpl $-0x1, %eax
jne 0x1075a
leaq 0x3164f(%rip), %rsi     # 0x41d9a
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc320
jmp 0x10797
movq %rsi, %r14
testb $0x1, %al
jne 0x10775
leaq 0x3281e(%rip), %rsi     # 0x42f86
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc320
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl (%r14), %esi
shrl %esi
movq %rbx, %rdi
callq 0xc190
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop