LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: fileExists(char const*)
int fileExists(const char* fname) {
  struct stat stFileInfo;
  int r=0;
  // Attempt to get the path attributes
  int fs = stat(fname,&stFileInfo);
  if (fs == 0) {
      r=3;
      // We were able to get the file attributes
      // so the path exists
      if (S_ISREG (stFileInfo.st_mode)) {
         r=2;
         }
      if (S_ISDIR (stFileInfo.st_mode)) {
          r=1;
          }
      }
  return r;
}

// Assembly:
subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
callq 0x2200
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2d70
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
xorl %ecx, %ecx
cmpl $0x8000, %eax           # imm = 0x8000
sete %cl
xorl $0x3, %ecx
cmpl $0x4000, %eax           # imm = 0x4000
movl $0x1, %eax
cmovnel %ecx, %eax
addq $0x98, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gfopen(char const*, char*)
FILE* Gfopen(const char *path, char *mode) {
	FILE* f=NULL;
	if (mode==NULL) f=fopen(path, "rb");
	    	   else f=fopen(path, mode);
	if (f==NULL)
		GMessage("Error opening file '%s':  %s\n", path, strerror(errno));
	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xb2f4(%rip), %rax      # 0xe09b
cmoveq %rax, %rsi
callq 0x22d0
movq %rax, %r14
testq %rax, %rax
je 0x2dc3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2593
jmp 0x2db8
nop
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, char const*, int)
int strsplit(char* str, GDynArray<char*>& fields, const char* delim, int maxfields) {
 //splits by placing 0 where any of the delim chars are found, setting fields[] to the beginning
 //of each field (stopping after maxfields); returns number of fields parsed
 int tidx=0;
 bool afterdelim=true;
 int i=0;
 fields.Reset();
 while (str[i]!=0 && tidx<maxfields) {
    if (afterdelim) {
       fields.Add(str+i);
       tidx++;
    }
    afterdelim=false;
    if (chrInStr(str[i],(char*)delim)) {
        str[i]=0;
        i++;
        while (str[i]!=0 && chrInStr(str[i], (char*)delim)) i++;
        afterdelim=true;
        continue;
    }
    i++;
 }
 return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, (%rsp)
movl $0x0, 0x18(%rsi)
cmpb $0x0, (%rdi)
sete %al
testl %ecx, %ecx
setle %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x3156
movq %rdx, %r14
movq %rdi, %r12
movb $0x1, %al
xorl %r15d, %r15d
movq %rdi, %r13
xorl %ebp, %ebp
testb $0x1, %al
je 0x30de
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x4600
incl %ebp
testq %r14, %r14
je 0x313c
cmpb $0x0, (%r14)
je 0x313c
movb (%r13), %al
movq %r14, %rcx
movb (%rcx), %dl
cmpb %al, %dl
je 0x30fd
incq %rcx
testb %dl, %dl
jne 0x30f0
testb %dl, %dl
je 0x313c
movb $0x0, (%r13)
movslq %r15d, %rax
leaq 0x1(%rax), %r15
testq %r14, %r14
je 0x3138
movb 0x1(%r12,%rax), %al
testb %al, %al
je 0x3138
cmpb $0x0, (%r14)
je 0x3138
movq %r14, %rdx
movb (%rdx), %cl
cmpb %al, %cl
je 0x3131
incq %rdx
testb %cl, %cl
jne 0x3124
movq %r15, %rax
testb %cl, %cl
jne 0x3109
movb $0x1, %al
jmp 0x3141
incl %r15d
xorl %eax, %eax
movslq %r15d, %r13
cmpb $0x0, (%r12,%r13)
je 0x3156
addq %r12, %r13
cmpl %ebx, %ebp
jl 0x30cc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, char, int)
int strsplit(char* str, GDynArray<char*>& fields, const char delim, int maxfields) {
  //splits by placing 0 where delim is found, setting fields[] to the beginning
  //of each field (stopping after maxfields); returns number of fields parsed
  int tidx=0;
  bool afterdelim=true;
  int i=0;
  fields.Reset();
  while (str[i]!=0 && tidx<maxfields) {
     if (afterdelim) {
    	 fields.Add(str+i);
         tidx++;
     }
     afterdelim=false;
     if (str[i]==delim) {
         str[i]=0;
         i++;
         while (str[i]!=0 && str[i]==delim) i++;
         afterdelim=true;
         continue;
     }
     i++;
  }
  return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rsi, 0x10(%rsp)
movl $0x0, 0x18(%rsi)
cmpb $0x0, (%rdi)
sete %al
testl %ecx, %ecx
setle %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x3221
movl %edx, %ebp
movq %rdi, %r15
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
xorl %r14d, %r14d
movq %rdi, %r13
xorl %r12d, %r12d
testb $0x1, %al
je 0x31e3
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4600
incl %r12d
cmpb %bpl, (%r13)
sete %al
jne 0x320c
movb $0x0, (%r13)
movslq %r14d, %rcx
addq 0x8(%rsp), %rcx
movb (%rcx), %dl
incl %r14d
testb %dl, %dl
je 0x320f
incq %rcx
cmpb %bpl, %dl
je 0x31f9
jmp 0x320f
incl %r14d
movslq %r14d, %r13
cmpb $0x0, (%r15,%r13)
je 0x3221
addq %r15, %r13
cmpl %ebx, %r12d
jl 0x31cf
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, int)
int strsplit(char* str,  GDynArray<char*>& fields, int maxfields) {
  //splits by placing 0 where delim is found, setting fields[] to the beginning
  //of each field (stopping after maxfields); returns number of fields parsed
  int tidx=0;
  bool afterdelim=true;
  int i=0;
  fields.Reset();
  while (str[i]!=0 && tidx<maxfields) {
     if (afterdelim) {
        fields.Add(str+i);
        tidx++;
     }
     afterdelim=false;
     if (str[i]==' ' || str[i]=='\t') {
         str[i]=0;
         i++;
         while (str[i]!=0 && (str[i]=='\t' || str[i]==' ')) i++;
         afterdelim=true;
         continue;
     }
     i++;
  }
  return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movl $0x0, 0x18(%rsi)
cmpb $0x0, (%rdi)
sete %al
testl %edx, %edx
setle %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x32cc
movl %edx, %ebx
movq %rdi, %r15
leaq 0x1(%rdi), %r13
movb $0x1, %al
xorl %r14d, %r14d
movq %rdi, %r12
xorl %ebp, %ebp
testb $0x1, %al
je 0x327f
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4600
incl %ebp
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0x328e
cmpl $0x9, %eax
jne 0x32b6
movb $0x0, (%r12)
movslq %r14d, %rax
leal 0x1(%rax), %r14d
addq %r13, %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x32aa
cmpl $0x9, %ecx
jne 0x32b2
incl %r14d
incq %rax
jmp 0x329d
movb $0x1, %al
jmp 0x32bb
incl %r14d
xorl %eax, %eax
movslq %r14d, %r12
cmpb $0x0, (%r15,%r12)
je 0x32cc
addq %r15, %r12
cmpl %ebx, %ebp
jl 0x326d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gsubstr(char const*, char*, char*)
char* Gsubstr(const char* str, char* from, char* to) {
 //extract (and allocate) a substring, including boundaries (from/to)
 if (str==NULL || from==NULL) return NULL;
 if (from[0]==0 || str[0]==0) return newEmptyStr();
 if (from<str) return NULL;
 if (to==NULL) {
    to=from;
    while (to[1]) to++;
    }
 if (to<from) return newEmptyStr();
 int newlen=to-from+1;
 char* subs=NULL;
 GMALLOC(subs, newlen);
 memcpy(subs, str, newlen-1);
 subs[newlen]='\0';
 return subs;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x3307
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, (%rsi)
je 0x3337
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3337
cmpq %rbx, %rsi
jb 0x32f5
movq %rdx, %r14
testq %rdx, %rdx
jne 0x3332
leaq -0x1(%rsi), %rax
leaq 0x1(%rax), %r14
cmpb $0x0, 0x2(%rax)
movq %r14, %rax
jne 0x3325
cmpq %rsi, %r14
jae 0x3347
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2989
subl %esi, %r14d
shlq $0x20, %r14
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %r14, %rax
movq %rax, %r12
sarq $0x20, %r12
testq %rax, %rax
je 0x3374
movq %r12, %rdi
callq 0x2330
movq %rax, %r15
jmp 0x3377
xorl %r15d, %r15d
testq %r15, %r15
je 0x3398
sarq $0x20, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movb $0x0, (%r15,%r12)
jmp 0x32f8
leaq 0xac81(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: replaceStr(char*&, char*)
char* replaceStr(char* &str, char* newvalue) {
 if (str!=NULL) GFREE(str);
 if (newvalue==NULL) { return NULL; }
 GMALLOC(str, strlen(newvalue)+1);
 strcpy(str,newvalue);
 return str;
 }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x33c4
callq 0x22e0
movq $0x0, (%rbx)
testq %r14, %r14
je 0x33fe
movq %r14, %rdi
callq 0x2140
movq $0x0, (%rbx)
incq %rax
je 0x33e8
movq %rax, %rdi
callq 0x2330
movq %rax, (%rbx)
cmpq $0x0, (%rbx)
je 0x3408
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2220
movq (%rbx), %rax
jmp 0x3400
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xac11(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gmemscan(void*, unsigned int, void*, unsigned int)
void* Gmemscan(void *mem, unsigned int len,
                   void *part, unsigned int partlen) {
char* p;
unsigned int restlen=len-partlen+1;
void* oldp=mem;
while ( (p=(char*)memchr(oldp, ((char*)part)[0], restlen))!=NULL) {
  //located first char, try to match the rest:
  p++;
  if (memcmp(p, &((char*)part)[1], partlen-1)==0) return p-1;
  //no string match, prepare next iteration
  restlen-=(p-(char*)oldp);
  oldp=p;
  }//while
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
subl %ecx, %r15d
incl %r15d
movsbl (%rdx), %esi
movl %esi, 0x4(%rsp)
movq %r15, %rdx
callq 0x22a0
testq %rax, %rax
je 0x3484
movq %rax, %r13
incq %r14
decl %ebx
leaq 0x1(%r13), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2260
testl %eax, %eax
je 0x3487
subl %ebp, %r12d
addl %r12d, %r15d
movq %rbp, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
callq 0x22a0
movq %rax, %r13
movq %rbp, %r12
testq %rax, %rax
jne 0x344e
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: rstrchr(char*, char)
char* rstrchr(char* str, char ch) {  /* returns a pointer to the rightmost
  occurence of ch in str  */
 char *p;
 if (str==NULL) return NULL;
 p=str+strlen(str)-1;
 while (p>=str) {
    if (*p==ch) return p;
    p--;
    }
 return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x34d3
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x2140
leaq (%rax,%r14), %rcx
decq %rcx
xorl %eax, %eax
cmpq %r14, %rcx
jb 0x34cb
leaq -0x1(%rcx), %rdx
cmpb %bl, (%rcx)
movq %rdx, %rcx
jne 0x34b5
incq %rdx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: fgetline(char*&, int&, _IO_FILE*, long*, int*)
char* fgetline(char* & buf, int& buf_cap, FILE *stream, off_t* f_pos, int* linelen) {
  //reads a char at a time until \n and/or \r are encountered
  int c=0;
  GDynArray<char> arr(buf, buf_cap);
  off_t fpos=(f_pos!=NULL) ? *f_pos : 0;
  while ((c=getc(stream))!=EOF) {
    if (c=='\n' || c=='\r') {
       if (c=='\r') {
         if ((c=getc(stream))!='\n') ungetc(c,stream);
                                else fpos++;
         }
       fpos++;
       break;
       }
    fpos++;
    arr.Push((char)c);
    } //while i<buf_cap-1
  //if (linelen!=NULL) *linelen=i;
  if (linelen!=NULL) *linelen=arr.Count();
  if (f_pos!=NULL) *f_pos=fpos;
  //if (c==EOF && i==0) return NULL;
  if (c==EOF && arr.Count()==0) return NULL;
  arr.Push('\0');
  buf=arr();
  buf_cap=arr.Capacity();
  return buf;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbp
movq (%rdi), %rax
movl (%rsi), %ecx
leaq 0x107f7(%rip), %rdx     # 0x13cf0
movq %rdx, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movl %ecx, 0x24(%rsp)
testq %r12, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
je 0x3529
movq (%r12), %r14
jmp 0x352c
xorl %r14d, %r14d
leaq 0x8(%rsp), %rbx
movq %rbp, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x355d
movl %eax, %r15d
cmpl $0xa, %eax
je 0x3586
cmpl $0xd, %r15d
je 0x3561
incq %r14
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x464a
jmp 0x3531
movb $0x1, %al
jmp 0x3590
movq %rbp, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x3579
incq %r14
movl $0xa, %r15d
jmp 0x3586
movl %eax, %r15d
movl %eax, %edi
movq %rbp, %rsi
callq 0x2070
incq %r14
cmpl $-0x1, %r15d
sete %al
testq %r13, %r13
je 0x359d
movl 0x20(%rsp), %ecx
movl %ecx, (%r13)
testq %r12, %r12
je 0x35a6
movq %r14, (%r12)
cmpl $0x0, 0x20(%rsp)
sete %cl
testb %cl, %al
je 0x35b6
xorl %ebx, %ebx
jmp 0x35da
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x464a
movq 0x18(%rsp), %rbx
movq 0x28(%rsp), %rax
movq %rbx, (%rax)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x1070f(%rip), %rax     # 0x13cf0
movq %rax, 0x8(%rsp)
cmpb $0x0, 0x10(%rsp)
jne 0x3605
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x35fc
callq 0x22e0
movq $0x0, 0x18(%rsp)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3619
movq %rax, %rbx
leaq 0x106cd(%rip), %rax     # 0x13cf0
movq %rax, 0x8(%rsp)
cmpb $0x0, 0x10(%rsp)
jne 0x3639
leaq 0x18(%rsp), %rdi
callq 0x25b8
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: GLineReader::getLine(_IO_FILE*, long&)
char* GLineReader::getLine(FILE* stream, off_t& f_pos) {
   if (pushed) { pushed=false; return buf(); }
   //reads a char at a time until \n and/or \r are encountered
   int c=0;
   textlen=0;
   buf.Reset(); //len = 0
   while ((c=getc(stream))!=EOF) {
     if (c=='\n' || c=='\r') {
       textlen=buf.Count();
       buf.Push('\0');
       if (c=='\r') { //DOS file -- special case
         if ((c=getc(stream))!='\n') ungetc(c,stream);
                                else f_pos++;
         }
       f_pos++;
       lcount++;
       return buf();
     }
     f_pos++;
     buf.Push(c);
     } //while i<buf_cap-1
   if (c==EOF) {
     isEOF=true;
     textlen=buf.Count();
     if (buf.Count()==0) return NULL;
     }
   textlen=buf.Count();
   buf.Push('\0');
   lcount++;
   return buf();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x40(%rdi)
jne 0x365c
movb $0x0, 0x40(%rbx)
jmp 0x36ec
movq %rdx, %r14
movq %rsi, %r15
xorl %eax, %eax
movl %eax, 0x28(%rbx)
leaq 0x8(%rbx), %r12
movl %eax, 0x20(%rbx)
movq %r15, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x36bf
movl %eax, %ebp
cmpl $0xd, %eax
je 0x3698
cmpl $0xa, %ebp
je 0x3698
incq (%r14)
movsbl %bpl, %esi
movq %r12, %rdi
callq 0x464a
jmp 0x366e
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x464a
cmpl $0xd, %ebp
jne 0x36e6
movq %r15, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x36dc
incq (%r14)
jmp 0x36e6
movb $0x1, 0x2c(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
testl %eax, %eax
je 0x36f9
movl %eax, 0x28(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x464a
jmp 0x36e9
movl %eax, %edi
movq %r15, %rsi
callq 0x2070
incq (%r14)
incl 0x44(%rbx)
movq 0x18(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x36f0
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strchrs(char const*, char const*)
char* strchrs(const char* s, const char* chrs) {
  if (s==NULL || chrs==NULL || *chrs=='\0' || *s=='\0')
         return NULL;
  unsigned int l=strlen(s);
  unsigned int r=strcspn(s, chrs);
  if (r==l) return NULL;
  return ((char*)s+r);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x3710
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x374e
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x374e
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
movq %rax, %rcx
movl %ecx, %edx
addq %rbx, %rdx
xorl %eax, %eax
cmpl %r15d, %ecx
cmovneq %rdx, %rax
jmp 0x3750
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: upCase(char const*)
char* upCase(const char* str) {
 if (str==NULL) return NULL;
 int len=strlen(str);
 char* upstr=NULL;
 GMALLOC(upstr, len+1);
 upstr[len]='\0';
 for (int i=0;i<len;i++) upstr[i]=toupper(str[i]);
 return upstr;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3792
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
movq %rax, %r12
shlq $0x20, %r12
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r12, %rdi
je 0x3797
sarq $0x20, %rdi
callq 0x2330
movq %rax, %r15
jmp 0x379a
xorl %r15d, %r15d
jmp 0x37cd
xorl %r15d, %r15d
testq %r15, %r15
je 0x37dc
sarq $0x20, %r12
movb $0x0, (%r15,%r12)
testl %r14d, %r14d
jle 0x37cd
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%rbx,%r12), %edi
callq 0x2430
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x37b7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa83d(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: loCase(char const*)
char* loCase(const char* str) {
 if (str==NULL) return NULL;
 int len=strlen(str);
 char* lostr=NULL;
 GMALLOC(lostr, len+1);
 lostr[len]='\0';
 for (int i=0;i<len;i++) lostr[i]=tolower(str[i]);
 return lostr;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3826
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
movq %rax, %r12
shlq $0x20, %r12
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r12, %rdi
je 0x382b
sarq $0x20, %rdi
callq 0x2330
movq %rax, %r15
jmp 0x382e
xorl %r15d, %r15d
jmp 0x3861
xorl %r15d, %r15d
testq %r15, %r15
je 0x3870
sarq $0x20, %r12
movb $0x0, (%r15,%r12)
testl %r14d, %r14d
jle 0x3861
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%rbx,%r12), %edi
callq 0x2380
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x384b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa7a9(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: rstrfind(char const*, char const*)
char* rstrfind(const char* str, const char* substr) {
/* like rindex() for a string */
 int l,i;
 if (str==NULL || *str=='\0') return NULL;
 if (substr==NULL || *substr=='\0') return NULL;
 l=strlen(substr);
 char* p=(char*)str+strlen(str)-l;
   //rightmost position that could match

 while (p>=str) {
    for (i=0; i<l && *(p+i) == *(substr+i); i++) ;
    if (i==l) return p; //found!
    p--;
    }
 return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x3975
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x396f
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x396f
cmpb $0x0, (%rbx)
je 0x396d
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x2140
addq %r14, %rax
movslq %r15d, %rcx
subq %rcx, %rax
cmpq %r14, %rax
jb 0x396d
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x0, %edx
testl %r15d, %r15d
jle 0x3960
xorl %edx, %edx
movb (%rax,%rdx), %sil
cmpb (%rbx,%rdx), %sil
jne 0x3960
incq %rdx
cmpq %rdx, %rcx
jne 0x394b
movl %r15d, %edx
cmpl %r15d, %edx
je 0x396f
decq %rax
cmpq %r14, %rax
jae 0x393f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strifind(char const*, char const*)
char* strifind(const char* str,  const char* substr) {
 // case insensitive version of strstr -- finding a string within another
  int l,i;
  if (str==NULL || *str==0) return NULL;
  if (substr==NULL || *substr==0) return NULL;
  l=strlen(substr);
  char* smax=(char*)str+strlen(str)-l;
  //rightmost position that could match
  char* p=(char*)str;
  while (p<=smax) {
     for (i=0; i<l && tolower(*(p+i))==tolower(*(substr+i)); i++) ;
     if (i==l) return p;
     p++;
     }
  return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x3a29
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %eax, %eax
testq %rsi, %rsi
je 0x3a1a
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3a1a
cmpb $0x0, (%r14)
je 0x3a18
movq %r14, %rdi
callq 0x2140
movq %rax, %r13
movq %rbx, %rdi
callq 0x2140
addq %rbx, %rax
movslq %r13d, %rcx
subq %rcx, %rax
movq %rax, (%rsp)
cmpq %rbx, %rax
jb 0x3a18
movl %r13d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x0, %r15d
testl %r13d, %r13d
jle 0x3a0a
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%r14,%r15), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3a0a
incq %r15
cmpq %r15, %r12
jne 0x39e5
movl %r13d, %r15d
cmpl %r13d, %r15d
je 0x3a2c
incq %rbx
cmpq (%rsp), %rbx
jbe 0x39d7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
movq %rbx, %rax
jmp 0x3a1a
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: startsiWith(char const*, char const*)
bool startsiWith(const char* s, const char* prefix) {
 if (prefix==NULL || s==NULL) return false;
 int i=0;
 while (prefix[i]!='\0' && tolower(prefix[i])==tolower(s[i])) i++;
 return (prefix[i]=='\0');
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3a89
xorl %ebp, %ebp
jmp 0x3add
movq %rsi, %rbx
movq %rdi, %r14
movsbl (%rsi), %edi
testl %edi, %edi
sete %bpl
je 0x3add
callq 0x2380
movl %eax, %r15d
movsbl (%r14), %edi
callq 0x2380
cmpl %eax, %r15d
jne 0x3add
movl $0x1, %r12d
movsbl (%rbx,%r12), %edi
testl %edi, %edi
sete %bpl
je 0x3add
callq 0x2380
movl %eax, %r15d
movsbl (%r14,%r12), %edi
callq 0x2380
incq %r12
cmpl %eax, %r15d
je 0x3ab6
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: endsWith(char const*, char const*)
bool endsWith(const char* s, const char* suffix) {
 if (suffix==NULL || s==NULL) return false;
 if (suffix[0]==0) return true; //special case: empty suffix
 int j=strlen(suffix)-1;
 int i=strlen(s)-1;
 if (i<j) return false;
 while (j>=0 && s[i]==suffix[j]) { i--; j--; }
 return (j==-1);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3afb
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x3b30
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
leal -0x1(%rax), %r12d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r12d, %eax
jge 0x3b34
xorl %eax, %eax
jmp 0x3b63
movb $0x1, %al
jmp 0x3b63
testl %r12d, %r12d
js 0x3b5c
cltq
addq %rax, %r14
leal -0x1(%r15), %r12d
movb (%r14), %al
cmpb (%rbx,%r12), %al
jne 0x3b5c
decq %r14
decl %r15d
testl %r15d, %r15d
jg 0x3b3e
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: endsiWith(char const*, char const*)
bool endsiWith(const char* s, const char* suffix) {
 if (suffix==NULL || s==NULL) return false;
 if (suffix[0]==0) return true; //special case: empty suffix
 int j=strlen(suffix)-1;
 int i=strlen(s)-1;
 if (i<j) return false;
 while (j>=0 && tolower(s[i])==tolower(suffix[j])) { i--; j--; }
 return (j==-1);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3b82
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x3bb5
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
decl %r15d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r15d, %eax
jge 0x3bb9
xorl %eax, %eax
jmp 0x3bfb
movb $0x1, %al
jmp 0x3bfb
testl %r15d, %r15d
js 0x3bf4
cltq
movl %r15d, %r15d
addq %rax, %r14
movsbl (%r14), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3bf4
leaq -0x1(%r15), %rax
decq %r14
testq %r15, %r15
movq %rax, %r15
jg 0x3bc6
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: trimSuffix(char*, char const*)
bool trimSuffix(char* s, const char* suffix) {
	if (suffix==NULL || s==NULL) return false;
	if (suffix[0]==0) return true; //special case: empty suffix
	int j=strlen(suffix)-1;
	int i=strlen(s)-1;
	if (i<j) return false;
	while (j>=0 && s[i]==suffix[j]) { i--; j--; }
	if (j==-1) { //suffix found
		s[i+1]='\0'; //cut here
		return true;
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x3c87
movq %rsi, %r15
movb $0x1, %bl
cmpb $0x0, (%rsi)
je 0x3c89
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %r12
leal -0x1(%rax), %r13d
movq %r14, %rdi
callq 0x2140
leal -0x1(%rax), %edx
cmpl %r13d, %edx
jl 0x3c87
testl %r13d, %r13d
js 0x3c7f
movslq %edx, %rsi
movl %r12d, %ecx
notl %ecx
addl %eax, %ecx
addq %r14, %rsi
leal -0x1(%r12), %r13d
movb (%rsi), %al
cmpb (%r15,%r13), %al
jne 0x3c7f
decl %edx
decq %rsi
decl %r12d
testl %r12d, %r12d
jg 0x3c5d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x3c81
movl %edx, %ecx
cmpl $-0x1, %r13d
je 0x3c95
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movslq %ecx, %rax
movb $0x0, 0x1(%r14,%rax)
jmp 0x3c89
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: trimiSuffix(char*, char const*)
bool trimiSuffix(char* s, const char* suffix) {
	if (suffix==NULL || s==NULL) return false;
	if (suffix[0]==0) return true; //special case: empty suffix
	int j=strlen(suffix)-1;
	int i=strlen(s)-1;
	if (i<j) return false;
	while (j>=0 && tolower(s[i])==tolower(suffix[j])) { i--; j--; }
	if (j==-1) { //suffix found
		s[i+1]='\0'; //cut here
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x3d4e
movq %rsi, %r15
movb $0x1, %bl
cmpb $0x0, (%rsi)
je 0x3d50
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %rbp
leal -0x1(%rax), %r13d
movq %r14, %rdi
callq 0x2140
leal -0x1(%rax), %r12d
cmpl %r13d, %r12d
jl 0x3d4e
testl %r13d, %r13d
js 0x3d3e
movslq %r12d, %rbx
movl %r13d, %r13d
notl %ebp
addl %eax, %ebp
movq %rbp, (%rsp)
addq %r14, %rbx
movsbl (%rbx), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%r15,%r13), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3d43
leaq -0x1(%r13), %rax
decl %r12d
decq %rbx
testq %r13, %r13
movq %rax, %r13
jg 0x3d06
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movb $0x1, %bl
movq (%rsp), %rax
jmp 0x3d48
movl %r12d, %eax
jmp 0x3d48
movl %r12d, %eax
movb $0x1, %bl
cmpl $-0x1, %r13d
je 0x3d61
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cltq
movb $0x0, 0x1(%r14,%rax)
jmp 0x3d50
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: reverseChars(char*, int)
char* reverseChars(char* str, int slen) {
  if (slen==0) slen=strlen(str);
  int l=0;
  int r=slen-1;
  char c;
  while (l<r) {
     c=str[l];str[l]=str[r];
     str[r]=c;
     l++;r--;
     }
  return str;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jne 0x3d7e
movq %rbx, %rdi
callq 0x2140
movq %rax, %rsi
cmpl $0x2, %esi
jl 0x3daa
movl %esi, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb 0x1(%rbx,%rax), %sil
movb %sil, (%rbx,%rcx)
movb %dl, 0x1(%rbx,%rax)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x3d8b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: rstrstr(char const*, char const*, char const*)
char* rstrstr(const char* rstart, const char *lend, const char* substr) {
 //like strstr, but starts searching from right end, going up to lend and
 //returns a pointer to the last (right) matching character in str
 char *p;
 int l,i;
 l=strlen(substr);
 p=(char*)rstart-l+1;
 while (p>=lend) {
    for (i=0;i<l;i++) if (*(p+i) != *(substr+i)) break;
    if (i==l) return p+l-1;
    p--;
    }
 return NULL;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2140
movslq %eax, %rdx
subq %rdx, %r14
incq %r14
cmpq %r15, %r14
jae 0x3dd7
xorl %ecx, %ecx
jmp 0x3e15
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movl $0x0, %edi
testl %eax, %eax
jle 0x3e00
xorl %edi, %edi
movb (%r14,%rdi), %r8b
cmpb (%rbx,%rdi), %r8b
jne 0x3e00
incq %rdi
cmpq %rdi, %rsi
jne 0x3dec
movl %eax, %edi
cmpl %eax, %edi
je 0x3e0e
decq %r14
cmpq %r15, %r14
jae 0x3de1
jmp 0x3e15
leaq (%r14,%rdx), %rcx
decq %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strhash(char const*)
int strhash(const char* str){
  int h=0;
  int g;
  while (*str) {
    h=(h<<4)+*str++;
    g=h&0xF0000000;
    if(g) h^=g>>24;
    h&=0x0fffffff;
    }
  GASSERT(h<=0x0fffffff);
  return h;
  }

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x3e4f
incq %rdi
xorl %edx, %edx
shll $0x4, %edx
movsbl %cl, %eax
addl %edx, %eax
movl %eax, %ecx
sarl $0x18, %ecx
andl $0xffffff0, %ecx        # imm = 0xFFFFFF0
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
xorl %ecx, %eax
movb (%rdi), %cl
incq %rdi
movl %eax, %edx
testb %cl, %cl
jne 0x3e29
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: djb_hash(char const*)
int djb_hash(const char* cp)
{
    int h = 5381;
    while (*cp)
        h = (int)(33 * h ^ (unsigned char) *cp++);
    return (h & 0x7FFFFFFF); //always positive
    //return h;
    //return absolute value of this int:
    //int mask = (h >> (sizeof(int) * CHAR_BIT - 1));
    //return (h + mask) ^ mask;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x3e7b
incq %rdi
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %edx
shll $0x5, %edx
addl %eax, %edx
movzbl %cl, %eax
xorl %edx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x3e60
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
movl $0x1505, %eax           # imm = 0x1505
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: delFileName(char*)
void delFileName(char* filepath) {
 char *p, *sep;
 if (filepath==NULL) return;
 for (p=filepath, sep=filepath;*p!='\0';p++)
     if (*p=='/' || *p=='\\') sep=p+1;
 *sep='\0'; // truncate filepath
}

// Assembly:
testq %rdi, %rdi
je 0x3ebc
leaq 0x1(%rdi), %rax
movzbl -0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x3eb1
cmpl $0x5c, %ecx
je 0x3eb1
testl %ecx, %ecx
jne 0x3eb4
jmp 0x3eb9
movq %rax, %rdi
incq %rax
jmp 0x3e9d
movb $0x0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: getFileExt(char const*)
const char* getFileExt(const char* filepath) {
 const char *p, *dp, *sep;
 if (filepath==NULL) return NULL;
 for (p=filepath, dp=filepath, sep=filepath;*p!='\0';p++) {
     if (*p=='.') dp=p+1;
       else if (*p=='/' || *p=='\\')
                  sep=p+1;
     }
 return (dp>sep) ? dp : NULL ;
}

// Assembly:
testq %rdi, %rdi
je 0x3f26
leaq 0x1(%rdi), %rax
movq %rdi, %rcx
movzbl -0x1(%rax), %edx
cmpl $0x2e, %edx
jle 0x3f0c
cmpl $0x2f, %edx
je 0x3f07
cmpl $0x5c, %edx
jne 0x3f17
movq %rax, %rcx
jmp 0x3f17
jne 0x3f13
movq %rax, %rdi
jmp 0x3f17
testl %edx, %edx
je 0x3f1c
incq %rax
jmp 0x3ef4
xorl %eax, %eax
cmpq %rcx, %rdi
cmovaq %rdi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: parseNumber(char*&, double&)
bool parseNumber(char* &p, double& v) {
 //skip any spaces..
 while (*p==' ' || *p=='\t') p++;
 char* start=p;
 /*if (*p=='-') p++;
       else if (*p=='+') { p++;start++; }*/

 /* while ((*p>='1' && *p<='9') || *p=='0' ||
          *p=='.' || *p=='-' || tolower(*p)=='e') p++; */
 int numlen=strspn(start, "0123456789eE.-+");
 p=start+numlen;
 //now p is on a non-digit;
 if (*start=='-' && p==start+1) return false;
 char saved=*p;
 *p='\0';
 char* endptr=p;
 v=strtod(start,&endptr);
 *p=saved;
 if (endptr!=p) return false;
 return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movzbl (%r15), %eax
cmpl $0x20, %eax
je 0x3f76
cmpl $0x9, %eax
jne 0x3f7e
incq %r15
movq %r15, (%rbx)
jmp 0x3f68
leaq 0xa13a(%rip), %rsi      # 0xe0bf
movq %r15, %rdi
callq 0x2120
movslq %eax, %rcx
shlq $0x20, %rax
addq %r15, %rcx
movq %rcx, (%rbx)
cmpb $0x2d, (%r15)
sete %dl
movabsq $0x100000000, %rsi      # imm = 0x100000000
cmpq %rsi, %rax
sete %al
testb %al, %dl
je 0x3fb9
xorl %eax, %eax
jmp 0x3feb
movb (%rcx), %bpl
movb $0x0, (%rcx)
movq (%rbx), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
movsd %xmm0, (%r14)
movq (%rbx), %rax
movb %bpl, (%rax)
movq (%r12), %rax
cmpq (%rbx), %rax
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: parseFloat(char*&, float&)
bool parseFloat(char* &p, float& v) {
 double dv;
 bool parsed=parseNumber(p,dv);
 if (parsed) v=(float)dv;
 return parsed;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x3f53
testb %al, %al
je 0x401d
cvtsd2ss 0x8(%rsp), %xmm0
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: parseInt(char*&, int&)
bool parseInt(char* &p, int& i) { //pointer p is advanced after the number
 while (*p==' ' || *p=='\t') p++;
 char* start=p;
 char* p0=p;
 if (*p=='-') p++;
      else if (*p=='+') { p++;start++; }
 char* atdigits=p;
 while (*p>='0' && *p<='9') p++;
 //now p should be past the digits
 if (atdigits==p) {//no digits found!
	 p=p0;
	 return false;
 }
 char* endptr=NULL;
 long l=strtol(start,&endptr,10);
 i=(int)l;
 if (endptr!=p || endptr==start || i!=l) {
	 p=p0;
	 return false;
 }
 return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r13
movzbl (%r13), %eax
cmpl $0x1f, %eax
jle 0x404a
cmpl $0x20, %eax
je 0x404f
jmp 0x4057
cmpl $0x9, %eax
jne 0x4076
incq %r13
movq %r13, (%rbx)
jmp 0x4039
cmpl $0x2b, %eax
je 0x406a
cmpl $0x2d, %eax
jne 0x4076
leaq 0x1(%r13), %rax
movq %r13, %r15
jmp 0x4071
leaq 0x1(%r13), %rax
movq %rax, %r15
movq %rax, (%rbx)
jmp 0x4079
movq %r13, %r15
movq (%rbx), %rax
movb (%rax), %dl
addb $-0x30, %dl
movq %rax, %rcx
cmpb $0x9, %dl
ja 0x40a0
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb (%rcx), %dl
addb $-0x30, %dl
incq %rcx
cmpb $0xa, %dl
jb 0x408d
decq %rcx
cmpq %rcx, %rax
je 0x40ea
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2360
movl %eax, (%r14)
movq (%r12), %rcx
movq (%rbx), %rdx
xorq %rcx, %rdx
cmpq %r15, %rcx
setne %cl
movslq %eax, %rsi
xorq %rax, %rsi
orq %rdx, %rsi
sete %al
andb %cl, %al
jne 0x40ef
movq %r13, (%rbx)
jmp 0x40ef
movq %r13, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strToInt(char*, int&)
bool strToInt(char* p, int& i) {
	 while (*p==' ' || *p=='\t') p++;
	 char* start=p;
	 if (*p=='-') p++;
	      else if (*p=='+') { p++;start++; }
	 char* atdigits=p;
	 while (*p>='0' && *p<='9') p++;
	 //now p should be past the digits
	 if (atdigits==p) //no digits found!
		 return false;
	 char* endptr=NULL;
	 long l=strtol(start,&endptr,10);
	 i=(int)l;
	 if (endptr!=p || endptr==start || i!=l)
		 return false;
	 return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rbx), %eax
cmpl $0x1f, %eax
jle 0x411a
cmpl $0x20, %eax
je 0x411f
jmp 0x4124
cmpl $0x9, %eax
jne 0x4137
incq %rbx
jmp 0x410b
cmpl $0x2b, %eax
je 0x4134
cmpl $0x2d, %eax
jne 0x4137
leaq 0x1(%rbx), %r12
jmp 0x413a
incq %rbx
movq %rbx, %r12
decq %r12
movl $0x1, %eax
movb 0x1(%r12), %cl
incq %r12
addb $-0x30, %cl
decq %rax
cmpb $0xa, %cl
jb 0x4142
testq %rax, %rax
je 0x4193
movq %rsp, %r15
movq $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2360
movl %eax, (%r14)
movq (%r15), %rcx
xorq %rcx, %r12
cmpq %rbx, %rcx
setne %cl
movslq %eax, %rdx
xorq %rax, %rdx
orq %r12, %rdx
sete %al
andb %cl, %al
jmp 0x4195
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: strToUInt(char*, unsigned int&)
bool strToUInt(char* p, uint& i) {
	while (*p==' ' || *p=='\t') p++;
	char* start=p;
	if (*p=='-') return false;
	else if (*p=='+') { p++;start++; }
	while (*p>='0' && *p<='9') p++;
	//now p is on a non-digit;
	if (start==p) return false;
	char* endptr=NULL;
	unsigned long l=strtoul(start,&endptr,10);
	i=(uint) l;
	if (endptr!=p || endptr==start || i!=l)
		return false;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x1f, %eax
jle 0x41bc
cmpl $0x20, %eax
je 0x41c1
jmp 0x41c6
cmpl $0x9, %eax
jne 0x41d5
incq %rdi
jmp 0x41ad
cmpl $0x2b, %eax
je 0x41d2
cmpl $0x2d, %eax
je 0x421c
jmp 0x41d5
incq %rdi
xorl %eax, %eax
movb (%rdi,%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x41d7
cmpq $0x1, %rax
je 0x421c
leaq (%rdi,%rax), %r15
decq %r15
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rsi
movl $0xa, %edx
callq 0x20d0
movl %eax, (%rbx)
xorq (%r14), %r15
shrq $0x20, %rax
orq %r15, %rax
sete %al
jmp 0x421e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: parseUInt(char*&, unsigned int&)
bool parseUInt(char* &p, uint& i) { //pointer p is advanced after the number
 while (*p==' ' || *p=='\t') p++;
 char* p0=p;
 char* start=p;
 if (*p=='-') return false;
       else if (*p=='+') { p++;start++; }
 while (*p>='0' && *p<='9') p++;
 //now p is on a non-digit;
 if (start==p) {
	 p=p0;
	 return false;
 }
 char* endptr=NULL;
 unsigned long l=strtoul(start,&endptr,10);
 i=(uint) l;
 if (endptr!=p || endptr==start || i!=l) {
	 p=p0;
	 return false;
 }
 return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r13
movzbl (%r13), %eax
cmpl $0x1f, %eax
jle 0x424f
cmpl $0x20, %eax
je 0x4254
jmp 0x425c
cmpl $0x9, %eax
jne 0x4266
incq %r13
movq %r13, (%rbx)
jmp 0x423e
cmpl $0x2b, %eax
je 0x426b
cmpl $0x2d, %eax
je 0x42e0
movq %r13, %r15
jmp 0x4272
leaq 0x1(%r13), %r15
movq %r15, (%rbx)
movq (%rbx), %rax
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x4295
incq %rax
movq %rax, (%rbx)
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x4282
decq %rax
cmpq %rax, %r15
je 0x42dd
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x20d0
movl %eax, (%r14)
movq (%r12), %rcx
movq (%rbx), %rdx
xorq %rcx, %rdx
cmpq %r15, %rcx
setne %cl
shrq $0x20, %rax
orq %rdx, %rax
sete %al
andb %cl, %al
jne 0x42e2
movq %r13, (%rbx)
jmp 0x42e2
movq %r13, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: parseHex(char*&, unsigned int&)
bool parseHex(char* &p, uint& i) {
 //skip initial spaces/prefix
 while (*p==' ' || *p=='\t' || *p=='0' || *p=='x') p++;
 char* start=p;
 if (*p=='-') return false;
       else if (*p=='+') { p++;start++; }
 while (isxdigit(*p)) p++;
 //now p is on a non-hexdigit;
 if (p==start+1) return false;
 char saved=*p;
 *p='\0';
 char* endptr=p;
 unsigned long l=strtoul(start,&endptr,16);
 i=(uint) l;
 *p=saved;
 if (endptr!=p || i!=l) return false;
 return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movzbl (%r15), %eax
cmpl $0x2c, %eax
jg 0x431a
cmpl $0x9, %eax
je 0x4324
cmpl $0x20, %eax
je 0x4324
jmp 0x432c
cmpl $0x30, %eax
je 0x4324
cmpl $0x78, %eax
jne 0x4339
incq %r15
movq %r15, (%r14)
jmp 0x4305
cmpl $0x2b, %eax
jne 0x433e
incq %r15
movq %r15, (%r14)
jmp 0x433e
cmpl $0x2d, %eax
je 0x43b5
movq (%r14), %r12
movb (%r12), %bpl
movsbl %bpl, %edi
callq 0x20a0
testl %eax, %eax
je 0x436f
incq %r12
movq %r12, (%r14)
movb (%r12), %bpl
movsbl %bpl, %edi
callq 0x20a0
incq %r12
testl %eax, %eax
jne 0x4355
decq %r12
leaq 0x1(%r15), %rax
cmpq %rax, %r12
je 0x43b5
movb $0x0, (%r12)
movq (%r14), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x20d0
movl %eax, (%rbx)
movq (%r14), %rcx
movb %bpl, (%rcx)
movq (%r12), %rcx
xorq (%r14), %rcx
movl (%rbx), %edx
xorq %rax, %rdx
orq %rcx, %rdx
sete %al
jmp 0x43b7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: writeFasta(_IO_FILE*, char const*, char const*, char const*, int, int)
void writeFasta(FILE *fw, const char* seqid, const char* descr,
        const char* seq, int linelen, int seqlen) {
  fflush(fw);
  // write header line only if given!
  if (seqid!=NULL) {
    if (descr==NULL || descr[0]==0)
             fprintf(fw,">%s\n",seqid);
        else fprintf(fw,">%s %s\n",seqid, descr);
    }
  fflush(fw);
  if (seq==NULL || *seq==0) return; //nothing to print
  if (linelen==0) { //unlimited line length: write the whole sequence on a line
     if (seqlen>0)
             fwrite((const void*)seq, 1, seqlen,fw);
        else fprintf(fw,"%s",seq);
     fprintf(fw,"\n");
     fflush(fw);
     return;
     }
  int ilen=0;
  if (seqlen>0) { //seq length given, so we know when to stop
    for (int i=0; i < seqlen; i++, ilen++) {
            if (ilen == linelen) {
                 fputc('\n', fw);
                 ilen = 0;
                 }
            fputc(seq[i], fw);
            }
    fputc('\n', fw);
    }
  else { //seq length not given, stop when 0 encountered
    for (int i=0; seq[i]!=0; i++, ilen++) {
            if (ilen == linelen) {
                 fputc('\n', fw);
                 ilen = 0;
                 }
            fputc(seq[i], fw);
            } //for
    fputc('\n', fw);
    }
  fflush(fw);
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
callq 0x22c0
testq %r12, %r12
je 0x4424
testq %r13, %r13
je 0x4410
cmpb $0x0, (%r13)
je 0x4410
leaq 0x9cd6(%rip), %rsi      # 0xe0d4
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2370
jmp 0x4424
leaq 0x9cb8(%rip), %rsi      # 0xe0cf
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2370
movq %rbx, %rdi
callq 0x22c0
testq %r14, %r14
je 0x4478
cmpb $0x0, (%r14)
je 0x4478
testl %ebp, %ebp
je 0x4487
testl %r15d, %r15d
jle 0x44a1
movl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl %ebp, %r13d
jne 0x445e
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2300
xorl %r13d, %r13d
movsbl (%r14,%r12), %edi
movq %rbx, %rsi
callq 0x2300
incq %r12
incl %r13d
cmpq %r12, %r15
jne 0x4449
jmp 0x44e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
jle 0x44de
movl %r15d, %edx
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2450
jmp 0x44e9
cmpb $0x0, (%r14)
je 0x44e9
incq %r14
xorl %r15d, %r15d
cmpl %ebp, %r15d
jne 0x44c2
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2300
xorl %r15d, %r15d
movsbl -0x1(%r14), %edi
movq %rbx, %rsi
callq 0x2300
incl %r15d
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x44ad
jmp 0x44e9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2300
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: commaprintnum(unsigned long)
char* commaprintnum(uint64 n) {
  char retbuf[48];
  int comma = ',';
  char *p = &retbuf[sizeof(retbuf)-1];
  int i = 0;
  *p = '\0';
  do {
    if(i%3 == 0 && i != 0)
        *--p = comma;
    *--p = '0' + n % 10;
    n /= 10;
    i++;
  } while(n != 0);
  return Gstrdup(p);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, %rcx
leaq 0x2f(%rsp), %rdi
movb $0x0, (%rdi)
xorl %esi, %esi
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r10d, %r10d
movl %esi, %eax
addl $-0x1, %esi
jae 0x4550
movl %r10d, %edx
imulq %r8, %rdx
shrq $0x21, %rdx
leal (%rdx,%rdx,2), %edx
addl %edx, %eax
jne 0x4550
movb $0x2c, -0x1(%rdi)
decq %rdi
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r11d
subl %eax, %r11d
orb $0x30, %r11b
movb %r11b, -0x1(%rdi)
decq %rdi
incl %r10d
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x4530
xorl %esi, %esi
callq 0x2936
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/./GBase.h
// Function: GDynArray<char*>::Grow()
void Grow() {
    	int delta = (fCapacity>16) ? (fCapacity>>2) : 2;
    	if (GDynArray_MAXCOUNT-delta<=fCapacity)
    		delta=GDynArray_MAXCOUNT-fCapacity;
    	if (delta<=1) GError("Error at GDynArray::Grow(): max capacity reached!\n");
    	growTo(fCapacity + delta);
    }

// Assembly:
movl 0x1c(%rdi), %eax
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x11, %eax
movl $0x2, %edx
cmovael %ecx, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
subl %edx, %ecx
subl %eax, %esi
cmpl %eax, %ecx
cmoval %edx, %esi
cmpl $0x1, %esi
jle 0x4763
addl 0x1c(%rdi), %esi
jmp 0x4772
pushq %rax
leaq 0x99ae(%rip), %rdi      # 0xe119
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/./GBase.h
// Function: GDynArray<char*>::growTo(unsigned int)
void growTo(uint newcap) {
    	if (newcap==0) { Clear(); return; }
    	if (newcap <= fCapacity) return; //never shrink! (use Pack() for shrinking)
    	GREALLOC(fArray, newcap*sizeof(OBJ));
    	fCapacity=newcap;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x4799
movl %esi, %ebp
cmpl %esi, 0x1c(%rbx)
jae 0x47c4
movl %ebp, %esi
shlq $0x3, %rsi
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x47a7
callq 0x23d0
jmp 0x47af
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47da
movq %rsi, %rdi
callq 0x2330
testq %rax, %rax
setne %cl
je 0x47bd
movq %rax, 0x10(%rbx)
jmp 0x47c1
testb %cl, %cl
je 0x47cb
movl %ebp, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x984e(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
nop
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/./GBase.h
// Function: GDynArray<char*>::Clear()
void Clear() { // clear array, shrinking its allocated memory
    	fCount = 0;
    	GREALLOC(fArray, sizeof(OBJ)*dyn_array_defcap);
    	// set initial memory size again
    	fCapacity = dyn_array_defcap;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x18(%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x47fa
movl $0x80, %esi
callq 0x23d0
jmp 0x4804
movl $0x80, %edi
callq 0x2330
testq %rax, %rax
setne %cl
je 0x4812
movq %rax, 0x10(%rbx)
jmp 0x4816
testb %cl, %cl
je 0x481f
movl $0x10, 0x1c(%rbx)
popq %rbx
retq
leaq 0x97fa(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
nop