LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4243
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4250
movq $0x0, -0x8(%rbp)
jmp 0x4323
cmpq $0x0, -0x18(%rbp)
je 0x4263
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4270
movq $0x0, -0x8(%rbp)
jmp 0x4323
movq -0x18(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x431b
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x42e5
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x42ee
jmp 0x42fb
jmp 0x42f0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x42b8
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x430d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4323
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x42a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4353
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4360
movq $0x0, -0x8(%rbp)
jmp 0x4450
cmpq $0x0, -0x18(%rbp)
je 0x4373
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4380
movq $0x0, -0x8(%rbp)
jmp 0x4450
movq -0x18(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x4448
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0x440f
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4418
jmp 0x4425
jmp 0x441a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x43d0
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x4437
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4450
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x43bf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: startsWith(char const*, char const*)
bool startsWith(const char* s, const char* prefix) {
 if (prefix==NULL || s==NULL) return false;
 int i=0;
 while (prefix[i]!='\0' && prefix[i]==s[i]) i++;
 return (prefix[i]=='\0');
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x447a
cmpq $0x0, -0x10(%rbp)
jne 0x4480
movb $0x0, -0x1(%rbp)
jmp 0x44e8
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x44bd
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x44c6
jmp 0x44d1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4487
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x450e
cmpq $0x0, -0x10(%rbp)
jne 0x4514
movb $0x0, -0x1(%rbp)
jmp 0x458e
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x4563
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x456c
jmp 0x4577
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x451b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x45be
cmpq $0x0, -0x10(%rbp)
jne 0x45c7
movb $0x0, -0x1(%rbp)
jmp 0x4660
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x45dc
movb $0x1, -0x1(%rbp)
jmp 0x4660
movq -0x18(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x460a
movb $0x0, -0x1(%rbp)
jmp 0x4660
jmp 0x460c
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jl 0x4637
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4640
jmp 0x4654
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x460c
cmpl $-0x1, -0x1c(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x468e
cmpq $0x0, -0x10(%rbp)
jne 0x4697
movb $0x0, -0x1(%rbp)
jmp 0x4742
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x46ac
movb $0x1, -0x1(%rbp)
jmp 0x4742
movq -0x18(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x46da
movb $0x0, -0x1(%rbp)
jmp 0x4742
jmp 0x46dc
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jl 0x4719
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4722
jmp 0x4736
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46dc
cmpl $-0x1, -0x1c(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x476e
cmpq $0x0, -0x10(%rbp)
jne 0x4777
movb $0x0, -0x1(%rbp)
jmp 0x4825
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x478c
movb $0x1, -0x1(%rbp)
jmp 0x4825
movq -0x18(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x47ba
movb $0x0, -0x1(%rbp)
jmp 0x4825
jmp 0x47bc
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jl 0x47e7
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x47f0
jmp 0x4804
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x47bc
cmpl $-0x1, -0x1c(%rbp)
jne 0x4821
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x4825
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x484e
cmpq $0x0, -0x10(%rbp)
jne 0x4857
movb $0x0, -0x1(%rbp)
jmp 0x4917
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x486c
movb $0x1, -0x1(%rbp)
jmp 0x4917
movq -0x18(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x489a
movb $0x0, -0x1(%rbp)
jmp 0x4917
jmp 0x489c
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jl 0x48d9
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x48e2
jmp 0x48f6
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x489c
cmpl $-0x1, -0x1c(%rbp)
jne 0x4913
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x4917
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x4951
movq -0x8(%rbp), %rdi
callq 0x2140
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x49af
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4961
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2140
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x4a67
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x4a3c
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4a2f
jmp 0x4a3c
jmp 0x4a31
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4a09
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x4a59
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a6f
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x49f8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4ae3
movl -0xc(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf0000000, %eax       # imm = 0xF0000000
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x4ad6
movl -0x10(%rbp), %eax
sarl $0x18, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x4a93
cmpl $0xfffffff, -0xc(%rbp)  # imm = 0xFFFFFFF
jg 0x4aee
jmp 0x4b06
leaq 0xf5cf(%rip), %rdi      # 0x140c4
leaq 0xf5d6(%rip), %rsi      # 0x140d2
movl $0x301, %edx            # imm = 0x301
callq 0x25e0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0xc(%rbp)     # imm = 0x1505
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4b45
imull $0x21, -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b1f
movl -0xc(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
popq %rbp
retq
nop
// File: gpertea[P]gclib/GBase.cpp
// Function: fnv1a_hash(char const*)
int fnv1a_hash(const char* cp) {
    int h = 0x811c9dc5;
    while (*cp) {
        h ^= (unsigned char) *cp++;
        h *= 0x01000193;
    }
    //return h;
    return (h & 0x7FFFFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x811c9dc5, -0xc(%rbp) # imm = 0x811C9DC5
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4b8c
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
imull $0x1000193, -0xc(%rbp), %eax # imm = 0x1000193
movl %eax, -0xc(%rbp)
jmp 0x4b5f
movl -0xc(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4bb1
jmp 0x4c08
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4c01
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x4be5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4bf1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4bf3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4bc1
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: getFileName(char const*)
const char* getFileName(const char* filepath) {
 const char *p, *sep;
 if (filepath==NULL) return NULL;
 for (p=filepath, sep=filepath;*p!='\0';p++)
     if (*p=='/' || *p=='\\') sep=p+1;
 return sep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c29
movq $0x0, -0x8(%rbp)
jmp 0x4c81
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4c79
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x4c5d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4c69
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4c6b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4c39
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cac
movq $0x0, -0x8(%rbp)
jmp 0x4d44
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4d20
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4cea
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4d10
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x4d02
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4d0e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4d10
jmp 0x4d12
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4cc4
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x4d34
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4d3c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4d3c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x31(%rbp)
je 0x4dd7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4de0
jmp 0x4df0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x4db0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xf2d6(%rip), %rsi      # 0x140dc
callq 0x2120
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4e46
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4e46
movb $0x0, -0x1(%rbp)
jmp 0x4e9f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21e0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb -0x25(%rbp), %cl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x4e9b
movb $0x0, -0x1(%rbp)
jmp 0x4e9f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4da0
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x4f19
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x41(%rbp)
je 0x4f67
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x4f70
jmp 0x4f80
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x4f40
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4fb5
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x4fe0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x4fde
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4fe0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x42(%rbp)
jl 0x5012
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x501b
jmp 0x502b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x4feb
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5049
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x50ac
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0xa, %edx
callq 0x2360
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5097
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x5097
movq -0x18(%rbp), %rax
movslq (%rax), %rax
cmpq -0x40(%rbp), %rax
je 0x50a8
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x50ac
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x50f1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x50fa
jmp 0x5108
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x50d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x512a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5150
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x514e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5150
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x3a(%rbp)
jl 0x5179
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x5182
jmp 0x5190
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5158
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x51a0
movb $0x0, -0x1(%rbp)
jmp 0x51f5
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x2360
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x51eb
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x51eb
movq -0x18(%rbp), %rax
movslq (%rax), %rax
cmpq -0x38(%rbp), %rax
je 0x51f1
movb $0x0, -0x1(%rbp)
jmp 0x51f5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x31(%rbp)
je 0x5231
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x523a
jmp 0x5248
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5210
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5265
movb $0x0, -0x1(%rbp)
jmp 0x5329
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x5289
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x528b
jmp 0x528d
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x32(%rbp)
jl 0x52ae
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x52b7
jmp 0x52c5
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x528d
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x52d5
movb $0x0, -0x1(%rbp)
jmp 0x5329
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x531f
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x531f
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpq -0x30(%rbp), %rax
je 0x5325
movb $0x0, -0x1(%rbp)
jmp 0x5329
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x5377
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5380
jmp 0x5390
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5350
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x53be
movb $0x0, -0x1(%rbp)
jmp 0x54ab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x53e7
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x53e9
jmp 0x53eb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x3a(%rbp)
jl 0x5412
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x541b
jmp 0x542b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x53eb
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5449
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x54ab
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x20d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5496
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x5496
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpq -0x38(%rbp), %rax
je 0x54a7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x54ab
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x551f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x39(%rbp)
je 0x551f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x39(%rbp)
je 0x551f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5528
jmp 0x5538
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x54d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x555b
movb $0x0, -0x1(%rbp)
jmp 0x5638
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x5584
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5586
jmp 0x5588
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x55ac
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5588
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x55c6
movb $0x0, -0x1(%rbp)
jmp 0x5638
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x20d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb -0x21(%rbp), %cl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x562e
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpq -0x38(%rbp), %rax
je 0x5634
movb $0x0, -0x1(%rbp)
jmp 0x5638
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2c, -0x44(%rbp)
leaq -0x40(%rbp), %rax
addq $0x2f, %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movl -0x54(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x588a
cmpl $0x0, -0x54(%rbp)
je 0x588a
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, -0x1(%rax)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, -0x1(%rax)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x585d
movq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x27b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gpertea[P]gclib/./GBase.h
// Function: GMalloc(void**, unsigned long)
inline bool GMalloc(pointer* ptr,unsigned long size){
    //GASSERT(ptr);
    *ptr=nullptr;
    if (size!=0)
  	  *ptr=malloc(size);
    return *ptr!=nullptr;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x5925
movq -0x10(%rbp), %rdi
callq 0x2330
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/./GBase.h
// Function: GDynArray<char*>::Pop()
OBJ Pop() { //shoddy.. Do NOT call this for an empty array!
    	if (fCount==0) return (OBJ)NULL; //a NULL cast operator is required
    	--fCount;
    	return fArray[fCount];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x18(%rax)
jne 0x5a60
movq $0x0, -0x8(%rbp)
jmp 0x5a7c
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x18(%rcx)
movq 0x10(%rcx), %rax
movl 0x18(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x10, 0x1c(%rax)
jbe 0x5de9
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5df3
movl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5df3
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
ja 0x5e19
movq -0x18(%rbp), %rcx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl 0x1c(%rcx), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x5e2d
leaq 0xe31e(%rip), %rdi      # 0x14144
movb $0x0, %al
callq 0x2640
movq -0x18(%rbp), %rdi
movl 0x1c(%rdi), %esi
addl -0xc(%rbp), %esi
callq 0x5e50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x5e78
movq -0x18(%rbp), %rdi
callq 0x5ec0
jmp 0x5eb8
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
ja 0x5e86
jmp 0x5eb8
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x5f10
testb $0x1, %al
jne 0x5eae
leaq 0xe17c(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x18(%rdi)
addq $0x10, %rdi
movl $0x80, %esi
callq 0x5f10
testb $0x1, %al
jne 0x5efb
leaq 0xe12f(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x10(%rbp), %rax
movl $0x10, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/./GBase.h
// Function: GRealloc(void**, unsigned long)
inline bool GRealloc(pointer* ptr,unsigned long size){
    //GASSERT(ptr);
    if (size==0) {
      GFree(ptr);
      return true;
      }
    if (*ptr==NULL) {//simple malloc
     void *p=malloc(size);
     if (p != NULL) {
       *ptr=p;
       return true;
       }
      else return false;
     }//malloc
    else {//realloc
     void *p=realloc(*ptr,size);
     if (p) {
         *ptr=p;
         return true;
         }
     return false;
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f36
movq -0x10(%rbp), %rdi
callq 0x5a90
movb $0x1, -0x1(%rbp)
jmp 0x5f9b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5f6b
movq -0x18(%rbp), %rdi
callq 0x2330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5f65
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5f9b
movb $0x0, -0x1(%rbp)
jmp 0x5f9b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x23d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5f97
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5f9b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::new_data(unsigned int, unsigned int)
GStr::Data * GStr::new_data(uint len, uint addcap) {
//static method to return a new Data object (allocate length)
//content is undefined, but it's null terminated
    if (len > 0) {
        Data* data;
        GMALLOC(data, sizeof(Data)+len+addcap);
        data->ref_count = 0;
        data->length = len;
        data->cap=len+addcap;
        data->chars[len] = '\0';
        return data;
        }
    else
        return &null_data;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jbe 0x6175
movl -0xc(%rbp), %eax
movl %eax, %esi
addq $0x10, %rsi
movl -0x10(%rbp), %eax
addq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x613e
leaq 0xdeec(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0xc(%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6180
leaq 0x140dc(%rip), %rax     # 0x1a258
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::new_data(char const*, unsigned int)
GStr::Data* GStr::new_data(const char* str, uint addcap) {
//static method to return a new Data object (allocate: length+addcap)
//as a copy of a given string
 //if (str==NULL) return &null_data;
 int len= (str==NULL)? 0 : strlen(str);
 if (len+addcap > 0) {
        Data* data;
        GMALLOC(data, sizeof(Data)+len+addcap);
        if (len) strcpy(data->chars, str);
        data->ref_count = 0;
        data->cap=len+addcap;
        data->length = len;
        data->chars[len] = '\0';
        return data;
        }
    else
        return &null_data;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61ae
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x61bb
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cmpl $0x0, %eax
jbe 0x6245
movslq -0x18(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x61f6
leaq 0xde34(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
cmpl $0x0, -0x18(%rbp)
je 0x620d
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movq -0x10(%rbp), %rsi
callq 0x2240
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, 0xc(%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6250
leaq 0x1400c(%rip), %rax     # 0x1a258
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)