LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: conservativeTo1DPrimative(std::vector<double, std::allocator<double>>)
vector<double> conservativeTo1DPrimative(vector<double> conservative)
{
  double gamma = 1.4;

  if (conservative.size()!=3)
    {
      printf("INCORRECT CONSERVATIVE VARIABLE SIZE!\n");
      return conservative;
    }


  double density = conservative[0]; 
  double velocity = conservative[1] / density;
  double spec_energy = conservative[2] / density;
  //from eq of state
  double int_energy = spec_energy - 0.5 * velocity * velocity;
  double pressure = int_energy * density*(gamma -1.);

  vector<double> primative(3,0.0);
  primative[0] = density;
  primative[1] = velocity;
  primative[2] = pressure;

  return primative;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x3479
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
pushq $0x3
popq %rsi
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x7c0c
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd 0x6eac(%rip), %xmm0     # 0xa2f0
mulsd %xmm2, %xmm0
movsd 0x18(%rsp), %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
mulsd 0x6e82(%rip), %xmm0     # 0xa2e8
movq (%rbx), %rax
movsd %xmm1, (%rax)
movsd %xmm2, 0x8(%rax)
movsd %xmm0, 0x10(%rax)
jmp 0x34a7
movq %rsi, %r14
leaq 0x6fcb(%rip), %rdi      # 0xa44e
callq 0x22b0
movupd (%r14), %xmm0
movupd %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintMeshData(mesh_t&)
int PrintMeshData(mesh_t &mesh)
{
  for (int k = 0; k < mesh.NCells; k++)
    {
      printf("%10.10f, %10.10f, %10.10f, %10.10f\n", mesh.FirstMeshElement[k], mesh.FirstDensityElement[k],
             mesh.FirstPressureElement[k], mesh.FirstVelocityElement[k]);
    }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x1dba(%rip), %r14      # 0xa5be
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x8843
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r15,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r15,8), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x2030
incq %r15
jmp 0x8804
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintDataToFile(mesh_t&, context_t&, int)
int PrintDataToFile(mesh_t &mesh, context_t &RiemannContext, int snapno)
{
  stringstream cppPath;
  cppPath <<  RiemannContext.SNAPSHOT_PATH << snapno;
  const char * PATH = (cppPath.str()).c_str();
  FILE * f = fopen(PATH, "w");
  
  for (int i = 0; i < mesh.NCells; i++)
    {
      fprintf(f,"%10.5f %10.5f %10.5f %10.5f\n", mesh.FirstMeshElement[i], 
	      mesh.FirstDensityElement[i], mesh.FirstPressureElement[i], mesh.FirstVelocityElement[i]);
    }
  fclose(f);
  
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0x38(%rsp), %rdi
subq $-0x80, %r14
movq %r14, %rsi
callq 0x21a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2300
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x22d0
leaq 0x8(%rsp), %rdi
movq (%rdi), %r14
callq 0x20e0
leaq 0x1d38(%rip), %rsi      # 0xa5e2
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
xorl %r12d, %r12d
leaq 0x1d25(%rip), %r15      # 0xa5e4
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x8901
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r12,8), %xmm0
movsd (%rcx,%r12,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r12,8), %xmm3
movq %r14, %rdi
movq %r15, %rsi
movb $0x4, %al
callq 0x2280
incq %r12
jmp 0x88bf
movq %r14, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rdi
callq 0x2160
xorl %eax, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8927
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: GAssert(char const*, char const*, unsigned int)
void GAssert(const char* expression, const char* filename, unsigned int lineno){
  char msg[4096];
  sprintf(msg,"%s(%d): ASSERT(%s) failed.\n",filename,lineno,expression);
  fprintf(stderr,"%s",msg);
  #ifdef DEBUG
  // modify here if you [don't] want a core dump
    abort();
  #endif
  exit(1);
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r8
leaq 0x9a61(%rip), %rsi      # 0xc004
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2080
movq 0xfa21(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: GError(char const*, ...)
void GError(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    _vsnprintf(msg, 4095, format, arguments);
    vfprintf(stderr, format, arguments); // if a console is available
    msg[4095]=0;
    va_end(arguments);
    OutputDebugString(msg);
    MessageBox(NULL,msg,NULL,MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    #ifdef DEBUG
     // comment this if you do NOT want a core dump
     //abort();
    #endif
  #endif
    exit(1);
  }

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2628
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xf989(%rip), %rax      # 0x11fd8
movq (%rax), %rdi
movq %r10, %rsi
callq 0x2340
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: GMessage(char const*, ...)
void GMessage(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr, format , arguments); // if a console is available
    _vsnprintf(msg, 4095, format, arguments);
    msg[4095]=0;
    va_end(arguments);
    fflush(stderr);
    //OutputDebugString(msg);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    fflush(stderr);
  #endif
  }

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x26c1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xf8f0(%rip), %rbx      # 0x11fd8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x2340
movq (%rbx), %rdi
callq 0x22c0
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, int)
char* Gstrdup(const char* str, int xtracap) {
  if (str==NULL) return NULL;
  char *copy=NULL;
  GMALLOC(copy, strlen(str)+1+xtracap);
  strcpy(copy,str);
  return copy;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x274e
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
callq 0x2140
movslq %ebp, %rcx
leaq (%rcx,%rax), %rsi
incq %rsi
movq %r14, %rdi
callq 0x415c
testb %al, %al
je 0x2759
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2220
movq 0x8(%rsp), %rax
jmp 0x2750
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x98c0(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: newEmptyStr()
char* newEmptyStr() {
  char* zs=NULL;
  GMALLOC(zs,1);
  zs[0]=0;
  return zs;
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
callq 0x2330
testq %rax, %rax
je 0x277a
movb $0x0, (%rax)
popq %rcx
retq
leaq 0x989f(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, char const*)
char* Gstrdup(const char* sfrom, const char* sto) {
  if (sfrom==NULL || sto==NULL) return NULL;
  char *copy=NULL;
  if (sfrom[0]==0 || sto<sfrom) return newEmptyStr();
  GMALLOC(copy, sto-sfrom+2);
  strncpy(copy, sfrom, sto-sfrom+1);
  copy[sto-sfrom+1]=0;
  return copy;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x27a0
xorl %eax, %eax
jmp 0x27ea
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rsp)
subq %rdi, %rbx
jb 0x27e5
cmpb $0x0, (%r14)
je 0x27e5
leaq 0x2(%rbx), %rsi
movq %rsp, %rdi
callq 0x415c
testb %al, %al
je 0x27f2
movq (%rsp), %rdi
leaq 0x1(%rbx), %rdx
movq %r14, %rsi
callq 0x2180
movq (%rsp), %rax
movb $0x0, 0x1(%rax,%rbx)
movq (%rsp), %rax
jmp 0x27ea
callq 0x2767
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9827(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: Gstrcmp(char const*, char const*, int)
int Gstrcmp(const char* a, const char* b, int n) {
 if (a==NULL || b==NULL) {
   return a==NULL ? -1 : 1;
   }
 else {
   if (n<0) return strcmp(a,b);
       else return strncmp(a,b,n);
 }
}

// Assembly:
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x281c
xorl %eax, %eax
cmpq $0x1, %rdi
sbbl %eax, %eax
orl $0x1, %eax
retq
testl %edx, %edx
js 0x2350
movl %edx, %edx
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/GBase.cpp
// Function: to_unix_path(char*)
char *to_unix_path(char *p) {
    if (p != NULL) {
        char *pp = p;
        while (*pp != 0) {
            if (*pp == '\\')
                *pp = '/';
            ++pp;
        }
    }
    return p;
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
je 0x2886
movq %rax, %rcx
movzbl (%rcx), %edx
cmpl $0x5c, %edx
je 0x287e
testl %edx, %edx
jne 0x2881
jmp 0x2886
movb $0x2f, (%rcx)
incq %rcx
jmp 0x2870
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b14
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
pushq $0x1
popq %rax
cmovnel %ecx, %eax
addq $0x98, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9550(%rip), %rax      # 0xc09b
cmoveq %rax, %rsi
callq 0x22d0
movq %rax, %r14
testq %rax, %rax
jne 0x2b7c
callq 0x2040
movl (%rax), %edi
callq 0x20e0
leaq 0x952f(%rip), %rdi      # 0xc09e
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2662
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x28, %rsp
movl %ecx, 0x14(%rsp)
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
andl $0x0, 0x18(%rsi)
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb $0x1, %r13b
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %rdi, 0x8(%rsp)
movslq %ebx, %r12
movb (%rdi,%r12), %al
testb %al, %al
je 0x2ee5
cmpl 0x14(%rsp), %ebp
jge 0x2ee5
leaq (%rdi,%r12), %r15
testb $0x1, %r13b
je 0x2e9c
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x4256
incl %ebp
movb (%r15), %al
movsbl %al, %edi
movq %r14, %rsi
callq 0x2ef6
movl %eax, %r13d
testb %al, %al
je 0x2edc
movb $0x0, (%r15)
incl %ebx
addq 0x18(%rsp), %r12
movl %ebx, %ecx
movl %ecx, %ebx
movb (%r12), %al
testb %al, %al
je 0x2ede
movsbl %al, %edi
movq %r14, %rsi
callq 0x2ef6
leal 0x1(%rbx), %ecx
incq %r12
testb %al, %al
jne 0x2ebb
jmp 0x2ede
incl %ebx
movq 0x8(%rsp), %rdi
jmp 0x2e6f
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
andl $0x0, 0x18(%rsi)
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %sil
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rdi, (%rsp)
movslq %r14d, %rbx
movb (%rdi,%rbx), %dl
testb %dl, %dl
je 0x2fa7
cmpl %r15d, %r12d
jge 0x2fa7
leaq (%rdi,%rbx), %r13
testb $0x1, %sil
je 0x2f7c
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4256
movq (%rsp), %rdi
incl %r12d
movb (%r13), %dl
cmpb %bpl, %dl
sete %sil
jne 0x2fa2
movb $0x0, (%r13)
addq 0x8(%rsp), %rbx
movb (%rbx), %dl
incl %r14d
incq %rbx
testb %dl, %dl
je 0x2f4b
cmpb %bpl, %dl
je 0x2f8f
jmp 0x2f4b
incl %r14d
jmp 0x2f4b
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_O2/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
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
andl $0x0, 0x18(%rsi)
leaq 0x1(%rdi), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
xorl %ebp, %ebp
xorl %r14d, %r14d
movslq %r14d, %r13
movb (%r15,%r13), %cl
testb %cl, %cl
je 0x304b
cmpl %ebx, %ebp
jge 0x304b
leaq (%r15,%r13), %r12
testb $0x1, %al
je 0x300f
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4256
incl %ebp
movb (%r12), %cl
cmpb $0x20, %cl
je 0x301c
movzbl %cl, %eax
cmpl $0x9, %eax
jne 0x3044
movb $0x0, (%r12)
incl %r14d
addq 0x10(%rsp), %r13
movzbl (%r13), %eax
cmpl $0x20, %eax
je 0x3038
cmpl $0x9, %eax
jne 0x3040
incl %r14d
incq %r13
jmp 0x3029
movb $0x1, %al
jmp 0x2fe5
incl %r14d
xorl %eax, %eax
jmp 0x2fe5
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x3081
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, (%rsi)
je 0x30b1
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x30b1
cmpq %rbx, %rsi
jb 0x3075
movq %rdx, %r14
testq %rdx, %rdx
jne 0x30ac
leaq -0x1(%rsi), %rax
leaq 0x1(%rax), %r14
cmpb $0x0, 0x2(%rax)
movq %r14, %rax
jne 0x309f
cmpq %rsi, %r14
jae 0x30bf
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2767
subl %esi, %r14d
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
shlq $0x20, %r14
movabsq $0x100000000, %r15      # imm = 0x100000000
addq %r14, %r15
sarq $0x20, %r15
movq %r15, %rsi
callq 0x415c
testb %al, %al
je 0x3114
movq 0x8(%rsp), %rdi
sarq $0x20, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movq 0x8(%rsp), %rax
movb $0x0, (%rax,%r15)
movq 0x8(%rsp), %rax
jmp 0x3077
leaq 0x8f05(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, (%rdi)
je 0x313a
movq %rbx, %rdi
callq 0x420d
testq %r14, %r14
je 0x3167
movq %r14, %rdi
callq 0x2140
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x415c
testb %al, %al
je 0x3171
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2220
movq (%rbx), %rax
jmp 0x3169
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8ea8(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rdi, %r15
subl %ecx, %ebp
incl %ebp
movsbl (%rdx), %eax
movl %eax, 0x4(%rsp)
incq %r14
decl %ebx
movl %ebp, %edx
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x22a0
movq %rax, %r12
testq %rax, %rax
je 0x31dc
leaq 0x1(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2260
testl %eax, %eax
je 0x31dc
subl %r13d, %r15d
addl %r15d, %ebp
movq %r13, %r15
jmp 0x31a4
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3228
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 0x3220
leaq -0x1(%rcx), %rdx
cmpb %bl, (%rcx)
movq %rdx, %rcx
jne 0x320a
incq %rdx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq %rsi, 0x20(%rsp)
movl (%rsi), %esi
leaq 0xeaa0(%rip), %rdi      # 0x11cf0
movq %rdi, (%rsp)
movb $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
andl $0x0, 0x18(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0x1c(%rsp)
testq %rcx, %rcx
je 0x3278
movq (%r12), %rbx
jmp 0x327a
xorl %ebx, %ebx
movq %rsp, %rbp
movq %r13, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x32a4
cmpl $0xa, %eax
je 0x32b8
cmpl $0xd, %eax
je 0x32a8
incq %rbx
movsbl %al, %esi
movq %rbp, %rdi
callq 0x42a2
jmp 0x327d
movb $0x1, %al
jmp 0x32d1
movq %r13, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x32bc
incq %rbx
xorl %eax, %eax
jmp 0x32ce
movl %eax, %ebp
movl %eax, %edi
movq %r13, %rsi
callq 0x2070
cmpl $-0x1, %ebp
sete %al
incq %rbx
testq %r15, %r15
je 0x32dd
movl 0x18(%rsp), %ecx
movl %ecx, (%r15)
testq %r12, %r12
je 0x32e6
movq %rbx, (%r12)
cmpl $0x0, 0x18(%rsp)
sete %cl
testb %cl, %al
je 0x32f7
xorl %r15d, %r15d
jmp 0x3314
movq %rsp, %rdi
xorl %esi, %esi
callq 0x42a2
movq 0x10(%rsp), %r15
movq %r15, (%r14)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
movq %rsp, %rdi
callq 0x42ee
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3330
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42ee
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x335e
movb $0x0, 0x40(%rbx)
jmp 0x33eb
movq %rdx, %r14
movq %rsi, %r15
andl $0x0, 0x28(%rbx)
leaq 0x8(%rbx), %r12
andl $0x0, 0x20(%rbx)
movq %r15, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x33c1
movl %eax, %ebp
cmpl $0xd, %eax
je 0x339a
cmpl $0xa, %ebp
je 0x339a
incq (%r14)
movsbl %bpl, %esi
movq %r12, %rdi
callq 0x42a2
jmp 0x3370
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x42a2
cmpl $0xd, %ebp
jne 0x33e5
movq %r15, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x33db
incq (%r14)
jmp 0x33e5
movb $0x1, 0x2c(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
testl %eax, %eax
je 0x33f8
movq %r12, %rdi
xorl %esi, %esi
callq 0x42a2
jmp 0x33e8
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 0x33ef
// File: /workspace/github_cpp_makefile_star2_O2/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 0x340f
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x344d
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x344d
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 0x344f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x34d4
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
movq %rax, %r15
shlq $0x20, %r15
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %r15, %rsi
sarq $0x20, %rsi
callq 0x415c
testb %al, %al
je 0x34e0
movq 0x8(%rsp), %rax
sarq $0x20, %r15
movb $0x0, (%rax,%r15)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x34cd
movsbl (%rbx,%r15), %edi
callq 0x2430
movq 0x8(%rsp), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x34b0
movq 0x8(%rsp), %rax
jmp 0x34d6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8b39(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x356d
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
movq %rax, %r15
shlq $0x20, %r15
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %r15, %rsi
sarq $0x20, %rsi
callq 0x415c
testb %al, %al
je 0x3579
movq 0x8(%rsp), %rax
sarq $0x20, %r15
movb $0x0, (%rax,%r15)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x3566
movsbl (%rbx,%r15), %edi
callq 0x2380
movq 0x8(%rsp), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x3549
movq 0x8(%rsp), %rax
jmp 0x356f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8aa0(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3654
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x3659
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x3659
cmpb $0x0, (%rbx)
je 0x3657
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x2140
addq %r14, %rax
movslq %r15d, %rcx
subq %rcx, %rax
testl %ecx, %ecx
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %r14, %rax
jb 0x3657
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3648
movb (%rax,%rdx), %sil
cmpb (%rbx,%rdx), %sil
jne 0x364a
incq %rdx
jmp 0x3634
movl %ecx, %edx
cmpl %r15d, %edx
je 0x3659
decq %rax
jmp 0x362d
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36f8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
xorl %eax, %eax
testq %rsi, %rsi
je 0x3702
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x3702
xorl %eax, %eax
cmpb $0x0, (%r15)
je 0x3702
movq %r15, %rdi
callq 0x2140
movq %rax, %rbx
movq %r14, %rdi
callq 0x2140
movq %rax, %r13
addq %r14, %r13
movslq %ebx, %rax
subq %rax, %r13
testl %eax, %eax
movl $0x0, %r12d
movq %rbx, (%rsp)
cmovgl %ebx, %r12d
cmpq %r13, %r14
ja 0x36fb
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x36eb
movsbl (%r14,%rbx), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%r15,%rbx), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x36ee
incq %rbx
jmp 0x36c7
movl %r12d, %ebx
cmpl (%rsp), %ebx
je 0x36ff
incq %r14
jmp 0x36c0
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x3702
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3759
xorl %ebp, %ebp
jmp 0x3789
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movsbl (%rbx,%r12), %edi
testl %edi, %edi
sete %bpl
je 0x3789
callq 0x2380
movl %eax, %r15d
movsbl (%r14,%r12), %edi
callq 0x2380
incq %r12
cmpl %eax, %r15d
je 0x3762
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x37a7
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x37d8
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
decl %r15d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r15d, %eax
jge 0x37dc
xorl %eax, %eax
jmp 0x380e
movb $0x1, %al
jmp 0x380e
movslq %eax, %rcx
cmpl $-0x1, %r15d
pushq $-0x1
popq %rax
cmovll %r15d, %eax
addq %rcx, %r14
testl %r15d, %r15d
js 0x3808
movb (%r14), %cl
movl %r15d, %edx
cmpb (%rbx,%rdx), %cl
jne 0x3805
decl %r15d
decq %r14
jmp 0x37ed
movl %r15d, %eax
cmpl $-0x1, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3827
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x385b
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
decl %r15d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r15d, %eax
jge 0x385f
xorl %eax, %eax
jmp 0x38a2
movb $0x1, %al
jmp 0x38a2
cltq
cmpl $-0x1, %r15d
pushq $-0x1
popq %r12
cmovll %r15d, %r12d
addq %rax, %r14
testl %r15d, %r15d
js 0x389b
movsbl (%r14), %edi
callq 0x2380
movl %eax, %ebp
movl %r15d, %eax
movsbl (%rbx,%rax), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3898
decl %r15d
decq %r14
jmp 0x3870
movl %r15d, %r12d
cmpl $-0x1, %r12d
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x392e
movq %rsi, %r15
movb $0x1, %bl
cmpb $0x0, (%rsi)
je 0x3930
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %r12
leal -0x1(%rax), %ebp
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %ebp, %eax
jl 0x392e
cltq
leaq (%r14,%rax), %rcx
shlq $0x20, %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
testl %ebp, %ebp
js 0x3919
movb (%rcx), %sil
movl %ebp, %edi
cmpb (%r15,%rdi), %sil
jne 0x392e
decl %ebp
addq %rdx, %rax
decq %rcx
jmp 0x3900
cmpl $0x80000000, %r12d      # imm = 0x80000000
ja 0x392e
sarq $0x20, %rax
movb $0x0, 0x1(%r14,%rax)
jmp 0x3930
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x394e
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movb $0x1, %al
cmpb $0x0, (%rsi)
je 0x39e1
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %rbx
leal -0x1(%rax), %r13d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r13d, %eax
jl 0x39df
movq %rbx, (%rsp)
movslq %eax, %r12
leaq (%r14,%r12), %rbx
shlq $0x20, %r12
testl %r13d, %r13d
js 0x39c8
movsbl (%rbx), %edi
callq 0x2380
movl %eax, %ebp
movl %r13d, %eax
movsbl (%r15,%rax), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x39df
decl %r13d
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %r12
decq %rbx
jmp 0x3993
cmpl $0x80000000, (%rsp)     # imm = 0x80000000
ja 0x39df
sarq $0x20, %r12
movb $0x0, 0x1(%r14,%r12)
movb $0x1, %al
jmp 0x39e1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a03
movq %rbx, %rdi
callq 0x2140
movq %rax, %rsi
movslq %esi, %rax
decq %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x3a26
movb (%rbx,%rcx), %dl
movb (%rbx,%rax), %sil
movb %sil, (%rbx,%rcx)
movb %dl, (%rbx,%rax)
incq %rcx
decq %rax
jmp 0x3a0b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rax, %rcx
movslq %ecx, %rdx
subq %rdx, %r14
incq %r14
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %esi
cmovgl %ecx, %esi
cmpq %r15, %r14
jb 0x3a86
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x3a74
movb (%r14,%rdi), %r8b
cmpb (%rbx,%rdi), %r8b
jne 0x3a76
incq %rdi
jmp 0x3a60
movl %esi, %edi
cmpl %ecx, %edi
je 0x3a7f
decq %r14
jmp 0x3a59
leaq (%r14,%rdx), %rax
decq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x3ab1
shll $0x4, %eax
incq %rdi
addl %ecx, %eax
movl %eax, %ecx
sarl $0x18, %ecx
andl $0xffffff0, %ecx        # imm = 0xFFFFFF0
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
xorl %ecx, %eax
jmp 0x3a8e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl $0x1505, %eax           # imm = 0x1505
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x3ac8
imull $0x21, %eax, %eax
incq %rdi
xorl %ecx, %eax
jmp 0x3ab7
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b09
leaq 0x1(%rdi), %rax
movzbl -0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x3afe
cmpl $0x5c, %ecx
je 0x3afe
testl %ecx, %ecx
jne 0x3b01
jmp 0x3b06
movq %rax, %rdi
incq %rax
jmp 0x3aea
movb $0x0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b71
leaq 0x1(%rdi), %rax
movq %rdi, %rcx
movzbl -0x1(%rax), %edx
cmpl $0x2e, %edx
je 0x3b5f
cmpl $0x2f, %edx
je 0x3b5a
cmpl $0x5c, %edx
je 0x3b5a
testl %edx, %edx
jne 0x3b62
jmp 0x3b67
movq %rax, %rcx
jmp 0x3b62
movq %rax, %rdi
incq %rax
jmp 0x3b41
xorl %eax, %eax
cmpq %rcx, %rdi
cmovaq %rdi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bc1
cmpl $0x9, %eax
jne 0x3bc9
incq %r15
movq %r15, (%rbx)
jmp 0x3bb3
leaq 0x84ef(%rip), %rsi      # 0xc0bf
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 0x3c04
xorl %eax, %eax
jmp 0x3c36
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_O2/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 0x3b9e
testb %al, %al
je 0x3c68
cvtsd2ss 0x8(%rsp), %xmm0
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x9, %eax
je 0x3c93
cmpl $0x20, %eax
jne 0x3c9b
incq %r13
movq %r13, (%rbx)
jmp 0x3c84
cmpl $0x2b, %eax
je 0x3cae
cmpl $0x2d, %eax
jne 0x3cba
leaq 0x1(%r13), %rax
movq %r13, %r15
jmp 0x3cb5
leaq 0x1(%r13), %rax
movq %rax, %r15
movq %rax, (%rbx)
jmp 0x3cc0
movq %r13, %rax
movq %r13, %r15
incq %rax
xorl %ecx, %ecx
movb -0x1(%rax), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x3cdb
movq %rax, (%rbx)
decq %rcx
incq %rax
jmp 0x3cc5
testq %rcx, %rcx
je 0x3d20
leaq 0x8(%rsp), %r12
andq $0x0, (%r12)
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
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 0x3d25
movq %r13, (%rbx)
jmp 0x3d25
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_O2/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 $0x9, %eax
je 0x3d4e
cmpl $0x20, %eax
jne 0x3d53
incq %rbx
jmp 0x3d41
cmpl $0x2b, %eax
je 0x3d63
cmpl $0x2d, %eax
jne 0x3d66
leaq 0x1(%rbx), %r12
jmp 0x3d69
incq %rbx
movq %rbx, %r12
decq %r12
pushq $0x1
popq %rax
movb 0x1(%r12), %cl
incq %r12
addb $-0x30, %cl
decq %rax
cmpb $0xa, %cl
jb 0x3d6f
testq %rax, %rax
je 0x3dbb
movq %rsp, %r15
andq $0x0, (%r15)
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
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 0x3dbd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x9, %eax
je 0x3de2
cmpl $0x20, %eax
jne 0x3de7
incq %rdi
jmp 0x3dd5
cmpl $0x2b, %eax
je 0x3df3
cmpl $0x2d, %eax
jne 0x3df6
jmp 0x3e38
incq %rdi
xorl %eax, %eax
movb (%rdi,%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x3df8
cmpq $0x1, %rax
je 0x3e38
leaq (%rdi,%rax), %r15
decq %r15
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x20d0
movl %eax, (%rbx)
xorq (%r14), %r15
shrq $0x20, %rax
orq %r15, %rax
sete %al
jmp 0x3e3a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq