LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::splitr(char)
GStr GStr::splitr(char c) {
 GStr result;
 int i=rindex(c);
 if (i>=0){
      result=substr(i+1);
      cut(i);
      return result;
      }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6660
movq -0x60(%rbp), %rdi
movsbl -0x11(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xa3f0
movl %eax, -0x58(%rbp)
jmp 0xa938
movl -0x58(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xa9ba
movq -0x60(%rbp), %rsi
movl -0x18(%rbp), %edx
incl %edx
leaq -0x50(%rbp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x9050
jmp 0xa95d
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6b20
jmp 0xa96c
leaq -0x50(%rbp), %rdi
callq 0x6990
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x9750
jmp 0xa988
movb $0x1, -0x12(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0xa9c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa9de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6990
jmp 0xa9de
movb $0x1, -0x12(%rbp)
movl $0x1, -0x54(%rbp)
testb $0x1, -0x12(%rbp)
jne 0xa9d4
movq -0x70(%rbp), %rdi
callq 0x6990
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6990
movq -0x20(%rbp), %rdi
callq 0x2400
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::startTokenize(char const*, enTokenizeMode)
void GStr::startTokenize(const char* delimiter, enTokenizeMode tokenizemode) {
 GFREE(fTokenDelimiter);
 if (delimiter) {
    GMALLOC(fTokenDelimiter,strlen(delimiter)+1);
    strcpy(fTokenDelimiter, delimiter);
    }
 fLastTokenStart=0;
 fTokenizeMode=tokenizemode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5a90
cmpq $0x0, -0x10(%rbp)
je 0xaa52
movq -0x10(%rbp), %rdi
callq 0x2140
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x58f0
testb $0x1, %al
jne 0xaa42
leaq 0x95e8(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2240
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::asInt(int&, int)
bool GStr::asInt(int& r, int base) {
 errno=0;
 char*endptr;
 long val=strtol(text(), &endptr, base);
 if (errno!=0) return false;
 if (endptr == text()) return false;
 /* If we got here, strtol() successfully parsed a number */
 r=val;
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2040
movq -0x38(%rbp), %rdi
movl $0x0, (%rax)
callq 0xb680
movq %rax, %rdi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x2360
movq %rax, -0x30(%rbp)
callq 0x2040
cmpl $0x0, (%rax)
je 0xb152
movb $0x0, -0x1(%rbp)
jmp 0xb185
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xb680
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0xb175
movb $0x0, -0x1(%rbp)
jmp 0xb185
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::asReal(double&)
bool GStr::asReal(double& r) {
  errno=0;
  char* endptr;
  double val=strtod(text(), &endptr);
  if (errno!=0) return false;
  if (endptr == text()) return false; //no digits to parse
  r=val;
  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, -0x30(%rbp)
callq 0x2040
movq -0x30(%rbp), %rdi
movl $0x0, (%rax)
callq 0xb680
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x21e0
movsd %xmm0, -0x28(%rbp)
callq 0x2040
cmpl $0x0, (%rax)
je 0xb20d
movb $0x0, -0x1(%rbp)
jmp 0xb241
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xb680
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0xb230
movb $0x0, -0x1(%rbp)
jmp 0xb241
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::peelInt() const
int GStr::peelInt() const {
 if (is_empty()) return 0;
 char buf[24];
 bool started=false;
 int j=0;
 int i;
 for (i=0;i<length();i++) {
  if (started) {
    if (isdigit(my_data->chars[i])) j++; //set coord
                               else break; //finished
    }
   else
    if (isdigit(my_data->chars[i])) {
        j++; started=true;
        }
  }
 if (j>0) {
   strncpy(buf, &my_data->chars[i-j], j);
   buf[j]='\0';
   return strtol(buf, NULL, 10);
   }
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6530
testb $0x1, %al
jne 0xb26f
jmp 0xb27b
movl $0x0, -0x4(%rbp)
jmp 0xb35d
movb $0x0, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0xb30c
testb $0x1, -0x31(%rbp)
je 0xb2d5
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %edi
callq 0x2210
cmpl $0x0, %eax
je 0xb2d1
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xb2d3
jmp 0xb30c
jmp 0xb2ff
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %edi
callq 0x2210
cmpl $0x0, %eax
je 0xb2fd
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movb $0x1, -0x31(%rbp)
jmp 0xb2ff
jmp 0xb301
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb28d
cmpl $0x0, -0x38(%rbp)
jle 0xb356
movq -0x48(%rbp), %rax
leaq -0x30(%rbp), %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movl -0x3c(%rbp), %eax
subl -0x38(%rbp), %eax
cltq
addq %rax, %rsi
movslq -0x38(%rbp), %rdx
callq 0x2190
movslq -0x38(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2360
movl %eax, -0x4(%rbp)
jmp 0xb35d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::peelIntR() const
int GStr::peelIntR() const {
 if (is_empty()) return 0;
 char buf[24];
 bool started=false;
 int j=0;
 int i;
 for (i=length()-1;i>=0;i--) {
  if (started) {
    if (isdigit(my_data->chars[i])) j++; //set length
                               else break; //finished
    }
   else
    if (isdigit(my_data->chars[i])) {
      j++; started=true;
      }
  }
 if (j>0) {
   strncpy(buf, &my_data->chars[i+1], j);
   buf[j]='\0';
   return strtol(buf, NULL, 10);
   }
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6530
testb $0x1, %al
jne 0xb38f
jmp 0xb39b
movl $0x0, -0x4(%rbp)
jmp 0xb473
movq -0x48(%rbp), %rdi
movb $0x0, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
callq 0xb660
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0xb422
testb $0x1, -0x31(%rbp)
je 0xb3eb
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %edi
callq 0x2210
cmpl $0x0, %eax
je 0xb3e7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xb3e9
jmp 0xb422
jmp 0xb415
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %edi
callq 0x2210
cmpl $0x0, %eax
je 0xb413
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movb $0x1, -0x31(%rbp)
jmp 0xb415
jmp 0xb417
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb3b5
cmpl $0x0, -0x38(%rbp)
jle 0xb46c
movq -0x48(%rbp), %rax
leaq -0x30(%rbp), %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rsi
movslq -0x38(%rbp), %rdx
callq 0x2190
movslq -0x38(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2360
movl %eax, -0x4(%rbp)
jmp 0xb473
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::to(char)
GStr GStr::to(char c) { //return the first part up to first occurence of c
 int i=index(c);
 if (i>=0) return substr(0,i);
      else return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %edx, %edx
movsbl -0x11(%rbp), %esi
callq 0x78f0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xb4d0
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %ecx
xorl %edx, %edx
callq 0x9050
jmp 0xb4dd
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6710
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::from(char)
GStr GStr::from(char c) { //same as to, but starting from the right side
 int i=rindex(c);
 if (i>=0) return substr(i+1);
      else return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movsbl -0x11(%rbp), %esi
callq 0xa3f0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xb549
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x9050
jmp 0xb556
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6710
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::count(char)
int GStr::count(char c){
 //return the number of occurences of char c within the string
 int result=0;
 for (int i=0;i<length();i++)
    if (my_data->chars[i]==c) result++;
 return result;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0xb5cf
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb5c2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb5c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb588
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: dbg_dequote(char*&)
void dbg_dequote(char* &p) {
   int alen=strlen(p);
   if (alen>1 && p[0]=='\'' && p[alen-1]=='\'') {
	 p++;
	 p[alen-2 ]='\0';
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2140
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xc2cb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0xc2cb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
jne 0xc2cb
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::validLongOpt(char*, char*)
int GArgs::validLongOpt(char* o, char* to) {
 char* pstr=Gstrdup(o,to);
 for (int i=0; i<fmtcount; i++) {
  if (fmt[i].longopt && strcmp(fmt[i].longopt, pstr)==0) {
       GFREE(pstr);
       return i;
       }
  }
 GFREE(pstr); 
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2880
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc3ea
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xc3dd
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2350
cmpl $0x0, %eax
jne 0xc3dd
leaq -0x28(%rbp), %rdi
callq 0x5a90
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc3fa
jmp 0xc3df
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc384
leaq -0x28(%rbp), %rdi
callq 0x5a90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::printError(_IO_FILE*, char const*, bool)
void GArgs::printError(FILE* fout, const char* usage, bool exitProgram) {
 if (errarg==0) return;
 if (usage) fprintf(fout, "%s\n", usage);
 if (err_valmissing) 
     fprintf(fout, "Error: value required for option '%s'\n", _argv[errarg]);
    else 
     fprintf(fout, "Error: invalid argument '%s'\n", _argv[errarg]);
 if (exitProgram)
     exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x38(%rax)
jne 0xc43b
jmp 0xc4b8
cmpq $0x0, -0x18(%rbp)
je 0xc458
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7c6c(%rip), %rsi      # 0x140bd
movb $0x0, %al
callq 0x2370
movq -0x28(%rbp), %rax
testb $0x1, 0x3c(%rax)
je 0xc486
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq 0x18(%rcx), %rax
movslq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x7dd0(%rip), %rsi      # 0x1424d
movb $0x0, %al
callq 0x2370
jmp 0xc4a8
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq 0x18(%rcx), %rax
movslq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x7dd3(%rip), %rsi      # 0x14274
movb $0x0, %al
callq 0x2370
testb $0x1, -0x19(%rbp)
je 0xc4b8
movl $0x1, %edi
callq 0x22f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::~GArgs()
GArgs::~GArgs() {
 int i;
 for (i=0; i<fmtcount; i++)
    GFREE(fmt[i].longopt);
 GFREE(fmt);
 for (i=0; i<count; i++) {
  GFREE(args[i].opt);
  GFREE(args[i].value);
  }
 GFREE(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc7cd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5a90
jmp 0xc7c0
jmp 0xc7c2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc79b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a90
jmp 0xc7dc
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xc833
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0x5a90
jmp 0xc80a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x8(%rax,%rcx,8), %rdi
callq 0x5a90
jmp 0xc826
jmp 0xc828
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc7e3
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x5a90
jmp 0xc842
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb650
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::getOpt(char const*)
char* GArgs::getOpt(const char* o) { /* retrieve the value for option o
                   returns 
                       NULL    if option not given at all
                     !=NULL    if boolean option was given
                     opt.value if value option was given
                     */
 for (int i=0; i<count; i++) 
  if (args[i].opt!=NULL && strcmp(args[i].opt, o)==0) 
           return args[i].value;
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xc972
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xc965
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2350
cmpl $0x0, %eax
jne 0xc965
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc97a
jmp 0xc967
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc8ff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::getOpt(char)
char* GArgs::getOpt(const char o) {
 for (int i=0; i<count; i++) 
  if (args[i].opt!=NULL && args[i].opt[0]==o && args[i].opt[1]=='\0') 
      return args[i].value;
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xca43
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xca33
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xca33
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0xca33
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xca4b
jmp 0xca35
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc9ad
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::getOpt(int)
char* GArgs::getOpt(int c) {
 for (int i=0; i<count; i++) 
  if (args[i].fmti>=0 && fmt[args[i].fmti].code==c)
      return args[i].value;
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xcaf3
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jl 0xcae6
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x20(%rcx), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xcae6
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcafb
jmp 0xcae8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xca7a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::getOptName(int)
char* GArgs::getOptName(int c) {
 for (int i=0; i<count; i++) 
  if (args[i].fmti>=0 && fmt[args[i].fmti].code==c)
      return args[i].opt;
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xcba2
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jl 0xcb95
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x20(%rcx), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xcb95
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcbaa
jmp 0xcb97
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcb2a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::nextNonOpt()
char* GArgs::nextNonOpt() { //get the next non-dashed argument
               //or NULL if no more 
for (int i=nonOptPos;i<count;i++)
 if (args[i].opt==NULL) {
      nonOptPos=i+1;
      return args[i].value;
      }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xcc3e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xcc31
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc46
jmp 0xcc33
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcbe6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::nextOpt()
char* GArgs::nextOpt() { //get the next non-dashed argument
               //or NULL if no more 
for (int i=optPos;i<count;i++)
 if (args[i].opt!=NULL) {
      optPos=i+1;
      return args[i].opt;
      }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x34(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xccdd
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xccd0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcce5
jmp 0xccd2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcc86
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GArgs.cpp
// Function: GArgs::nextCode()
int GArgs::nextCode() { //get the next non-dashed argument
               //or NULL if no more 
for (int i=optPos;i<count;i++)
 if (args[i].opt!=NULL && args[i].fmti>=0) {
      optPos=i+1;
      return fmt[args[i].fmti].code;
      }
return 0; //must make sure that codes are > 0 for this to work properly
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x34(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xcd84
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xcd77
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jl 0xcd77
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rcx)
movq 0x8(%rcx), %rax
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd8b
jmp 0xcd79
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd06
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: gpertea[P]gclib/GResUsage.cpp
// Function: getCurrentMemUse()
size_t getCurrentMemUse() {
#if defined(_WIN32)
	// -- Windows
	PROCESS_MEMORY_COUNTERS info;
	GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
	return (size_t)info.WorkingSetSize;

#elif defined(__APPLE__) && defined(__MACH__)
#if defined MACH_TASK_BASIC_INFO
	struct mach_task_basic_info info;
#else
  struct task_basic_info info;
  #define MACH_TASK_BASIC_INFO TASK_BASIC_INFO
  #define MACH_TASK_BASIC_INFO_COUNT TASK_BASIC_INFO_COUNT
#endif

	mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
	if ( task_info( mach_task_self( ), MACH_TASK_BASIC_INFO,
		(task_info_t)&info, &infoCount ) != KERN_SUCCESS )
		return (size_t)0L;		// Can't access?
	return (size_t)info.resident_size;
#else
	//-- assume Linux
	long progsize = 0L;
	FILE* fp = NULL;
	if ( (fp = fopen( "/proc/self/statm", "r" )) == NULL )
		return (size_t)0L;		/* Can't open? */
	//if ( fscanf( fp, "%*s%ld", &rss ) != 1 )
	if ( fscanf( fp, "%*s%ld", &progsize ) != 1 )
	{
		fclose( fp );
		return (size_t)0L;		/* Can't read? */
	}
	fclose( fp );
	int page_size=sysconf(_SC_PAGESIZE);
	return ((size_t)progsize * (size_t)page_size);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x7491(%rip), %rdi      # 0x142d0
leaq 0x72b5(%rip), %rsi      # 0x140fb
callq 0x22d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xce5f
movq $0x0, -0x8(%rbp)
jmp 0xceb3
movq -0x18(%rbp), %rdi
leaq 0x7477(%rip), %rsi      # 0x142e1
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x2430
cmpl $0x1, %eax
je 0xce8d
movq -0x18(%rbp), %rdi
callq 0x2250
movq $0x0, -0x8(%rbp)
jmp 0xceb3
movq -0x18(%rbp), %rdi
callq 0x2250
movl $0x1e, %edi
callq 0x21c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GResUsage.cpp
// Function: GResUsage::start()
double GResUsage::start() {
	started=true;
	stopped=false;
	start_mem=getCurrentMemUse();
	double mem=(double)start_mem/1024;
	GMessage("   start_mem=%.2f\n", mem);
	getrusage(RUSAGE_SELF, &start_ru);
	G_gettime(start_ts);
	double tm=start_ts.tv_sec*1000000.0 + start_ts.tv_nsec/1000.0;
	return tm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, (%rax)
movb $0x0, 0x1(%rax)
callq 0xce20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %xmm0
movaps 0x72f9(%rip), %xmm1     # 0x142b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x72fd(%rip), %xmm1     # 0x142c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x72be(%rip), %xmm1     # 0x14298
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
leaq 0x7311(%rip), %rdi      # 0x14300
movb $0x1, %al
callq 0x26f0
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
xorl %edi, %edi
callq 0x21b0
movq -0x20(%rbp), %rsi
addq $0x138, %rsi            # imm = 0x138
movl $0x1, %edi
callq 0x2230
movq -0x20(%rbp), %rax
cvtsi2sdq 0x138(%rax), %xmm0
cvtsi2sdq 0x140(%rax), %xmm1
movsd 0x7270(%rip), %xmm2     # 0x142a8
divsd %xmm2, %xmm1
movsd 0x725c(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GResUsage.cpp
// Function: GResUsage::stop()
double GResUsage::stop() {
	if (started!=true)
		GError("Error: calling GResUsage::stop() without starting it first?\n");
	stopped=true;
	G_gettime(stop_ts);
	getrusage(RUSAGE_SELF, &stop_ru);
	double tm=stop_ts.tv_sec*1000000.0 + stop_ts.tv_nsec/1000.0;
	stop_mem=getCurrentMemUse();
	double mem=(double)stop_mem/1024;
	GMessage("   stop_mem=%.2f\n", mem);

	return tm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xd08e
leaq 0x728c(%rip), %rdi      # 0x14313
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rsi
movb $0x1, 0x1(%rsi)
addq $0x148, %rsi            # imm = 0x148
movl $0x1, %edi
callq 0x2230
movq -0x20(%rbp), %rsi
addq $0xa8, %rsi
xorl %edi, %edi
callq 0x21b0
movq -0x20(%rbp), %rax
cvtsi2sdq 0x148(%rax), %xmm0
cvtsi2sdq 0x150(%rax), %xmm1
movsd 0x71d1(%rip), %xmm2     # 0x142a8
divsd %xmm2, %xmm1
movsd 0x71bd(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0xce20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %xmm0
movaps 0x71a4(%rip), %xmm1     # 0x142b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x71a8(%rip), %xmm1     # 0x142c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x7169(%rip), %xmm1     # 0x14298
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
leaq 0x720c(%rip), %rdi      # 0x14350
movb $0x1, %al
callq 0x26f0
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GResUsage.cpp
// Function: GResUsage::elapsed()
double GResUsage::elapsed() {
	stopCheck("elapsed");
	double st=start_ts.tv_sec*1000000.0 + start_ts.tv_nsec/1000.0;
	double et=stop_ts.tv_sec*1000000.0 + stop_ts.tv_nsec/1000.0;
	return (et-st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x71ec(%rip), %rsi      # 0x143a7
callq 0xd160
movq -0x20(%rbp), %rax
cvtsi2sdq 0x138(%rax), %xmm0
cvtsi2sdq 0x140(%rax), %xmm1
movsd 0x70ca(%rip), %xmm2     # 0x142a8
divsd %xmm2, %xmm1
movsd 0x70b6(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdq 0x148(%rax), %xmm0
cvtsi2sdq 0x150(%rax), %xmm1
movsd 0x7097(%rip), %xmm2     # 0x142a8
divsd %xmm2, %xmm1
movsd 0x7083(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GResUsage.cpp
// Function: GResUsage::u_elapsed()
double GResUsage::u_elapsed() {
	stopCheck("u_elapsed");
	double st=start_ru.ru_utime.tv_sec*1000000.0 + start_ru.ru_utime.tv_usec;
	double et=stop_ru.ru_utime.tv_sec*1000000.0 + stop_ru.ru_utime.tv_usec;
	return (et-st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x7140(%rip), %rsi      # 0x1439b
callq 0xd160
movq -0x20(%rbp), %rax
cvtsi2sdq 0x18(%rax), %xmm0
cvtsi2sdq 0x20(%rax), %xmm1
movsd 0x7028(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdq 0xa8(%rax), %xmm0
cvtsi2sdq 0xb0(%rax), %xmm1
movsd 0x7001(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GResUsage.cpp
// Function: GResUsage::s_elapsed()
double GResUsage::s_elapsed() {
	stopCheck("s_elapsed");
	double st=start_ru.ru_stime.tv_sec*1000000.0 + start_ru.ru_stime.tv_usec;
	double et=stop_ru.ru_stime.tv_sec*1000000.0 + stop_ru.ru_stime.tv_usec;
	return (et-st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x70ca(%rip), %rsi      # 0x143a5
callq 0xd160
movq -0x20(%rbp), %rax
cvtsi2sdq 0x28(%rax), %xmm0
cvtsi2sdq 0x30(%rax), %xmm1
movsd 0x6fa8(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdq 0xb8(%rax), %xmm0
cvtsi2sdq 0xc0(%rax), %xmm1
movsd 0x6f81(%rip), %xmm2     # 0x142a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/htest.cpp
// Function: showTimings(GResUsage)
void showTimings(GResUsage swatch) {
 char *wtime=commaprintnum((uint64_t)swatch.elapsed());
 char *utime=commaprintnum((uint64_t)swatch.u_elapsed());
 char *stime=commaprintnum((uint64_t)swatch.s_elapsed());
 char *smem=commaprintnum((uint64_t)swatch.memoryUsed());
 GMessage("Elapsed time (microseconds): %12s us\n", wtime);
 GMessage("                  user time: %12s us\n", utime);
 GMessage("                system time: %12s us\n", stime);
 GMessage("                  mem usage: %12s KB\n", smem);

 GFREE(wtime);GFREE(utime);GFREE(stime); GFREE(smem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xd1a0
movsd 0x6bd3(%rip), %xmm2     # 0x143c0
movsd %xmm2, -0x28(%rbp)
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rdi
movq %rdi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, -0x8(%rbp)
callq 0xd240
movsd -0x28(%rbp), %xmm2
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rdi
movq %rdi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0xd2c0
movsd -0x28(%rbp), %xmm2
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rdi
movq %rdi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xd340
movsd -0x28(%rbp), %xmm2
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rdi
movq %rdi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rdi
callq 0x5830
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x6b76(%rip), %rdi      # 0x14439
movb $0x0, %al
callq 0x26f0
movq -0x10(%rbp), %rsi
leaq 0x6b8a(%rip), %rdi      # 0x1445f
movb $0x0, %al
callq 0x26f0
movq -0x18(%rbp), %rsi
leaq 0x6b9e(%rip), %rdi      # 0x14485
movb $0x0, %al
callq 0x26f0
movq -0x20(%rbp), %rsi
leaq 0x6bb2(%rip), %rdi      # 0x144ab
movb $0x0, %al
callq 0x26f0
leaq -0x8(%rbp), %rdi
callq 0x5a90
leaq -0x10(%rbp), %rdi
callq 0x5a90
leaq -0x18(%rbp), %rdi
callq 0x5a90
leaq -0x20(%rbp), %rdi
callq 0x5a90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/./GVec.hh
// Function: GPVec<HStrData>::Add(HStrData*)
int GPVec<OBJ>::Add(OBJ* item) {
 int result;
 if (item==NULL) return -1;
 result = fCount;
 if (result==fCapacity) this->Grow();
 fList[result]=item;
 fCount++;
 return fCount-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xff58
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xff99
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x14(%rcx), %eax
jne 0xff73
movq -0x28(%rbp), %rdi
callq 0x113b0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gpertea[P]gclib/./GHash.hh
// Function: old::GHash<int>::GHash(bool)
GHash<OBJ>::GHash(bool doFree) {
	GMALLOC(hash, sizeof(GHashEntry)*DEF_HASH_SIZE);
	fCurrentEntry=-1;
	lastkeyptr=NULL;
	fFreeProc = (doFree)?&DefaultFreeProc : NULL;
	for (uint i=0; i<DEF_HASH_SIZE; i++)
		hash[i].hash=-1; //this will be an indicator for 'empty' entries
	fCapacity=DEF_HASH_SIZE;
	fCount=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x9cbd(%rip), %rax      # 0x19d40
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x300, %esi            # imm = 0x300
callq 0x58f0
testb $0x1, %al
jne 0x100aa
leaq 0x3f80(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x20(%rax)
movb -0x9(%rbp), %sil
xorl %ecx, %ecx
leaq 0x1286(%rip), %rdx      # 0x11350
testb $0x1, %sil
cmovneq %rdx, %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jae 0x10107
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x100dd
movq -0x18(%rbp), %rax
movl $0x20, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/./GHash.hh
// Function: old::GHash<int>::Clear()
void GHash<OBJ>::Clear(){
	int i;
	for(i=0; i<fCapacity; i++){
		if(hash[i].hash>=0){
			if (hash[i].keyalloc) GFREE((hash[i].key));
			if (FREEDATA)
				(*fFreeProc)(hash[i].data);
		}
	}
	GFREE(hash);
	GMALLOC(hash, sizeof(GHashEntry)*DEF_HASH_SIZE);
	//reinitialize it
	for (i=0; i<DEF_HASH_SIZE; i++)
		hash[i].hash=-1; //this will be an indicator for 'empty' entries
	fCapacity=DEF_HASH_SIZE;
	fCount=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x101cf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0xc(%rax)
jl 0x101bf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x8(%rax)
je 0x10195
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5a90
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x101bd
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rdi
callq *%rax
jmp 0x101bf
jmp 0x101c1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1013b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a90
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x300, %esi            # imm = 0x300
callq 0x58f0
testb $0x1, %al
jne 0x10200
leaq 0x3e2a(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x10232
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10207
movq -0x18(%rbp), %rax
movl $0x20, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/./GHash.hh
// Function: old::GHash<int>::~GHash()
GHash<OBJ>::~GHash(){
	for(int i=0; i<fCapacity; i++){
		if(hash[i].hash>=0){
			if (hash[i].keyalloc) GFREE((hash[i].key));
			if (FREEDATA) (*fFreeProc)(hash[i].data);
		}
	}
	GFREE(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x9395(%rip), %rcx      # 0x19d40
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x10a54
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0xc(%rax)
jl 0x10a44
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x8(%rax)
je 0x10a18
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0x5a90
jmp 0x10a16
jmp 0x10a18
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x10a42
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rdx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x10a40
jmp 0x10a42
jmp 0x10a44
jmp 0x10a46
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x109b9
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a90
jmp 0x10a63
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb650
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: gpertea[P]gclib/./khashl.hh
// Function: klib::KHashSet<klib::KHashMapCachedBucket<char const*, int, unsigned int>, klib::KHashCachedHash<klib::KHashMapCachedBucket<char const*, int, unsigned int>, unsigned int>, klib::KHashCachedEq<klib::KHashMapCachedBucket<char const*, int, unsigned int>, cstr_eq>, unsigned int>::del(unsigned int)
int del(khint_t i) {
		khint_t j = i, k, mask, nb = n_buckets();
		if (keys == 0 || i >= nb) return 0;
		mask = nb - khint_t(1);
		while (1) {
			j = (j + khint_t(1)) & mask;
			if (j == i || !__kh_used(used, j)) break; // j==i only when the table is completely full
			k = __kh_h2b(Hash()(keys[j]), bits);
			if ((j > i && (k <= i || k > j)) || (j < i && (k <= i && k > j)))
				keys[i] = keys[j], i = j;
		}
		__kh_set_unused(used, i);
		--count;
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x11da0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x24(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x10b3a
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jb 0x10b46
movl $0x0, -0x4(%rbp)
jmp 0x10c35
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
andl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x10b78
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x12130
cmpl $0x0, %eax
jne 0x10b7d
jmp 0x10c11
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x18(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rsi
leaq -0x25(%rbp), %rdi
callq 0x12110
movl %eax, %edi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x120f0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x10bc0
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x10bd8
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
ja 0x10bd8
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x10c0c
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x10c0c
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jbe 0x10c0c
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x18(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x10(%rax), %rax
movl -0x14(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x10b4f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x12210
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/./GHashMap.hh
// Function: GHashMap<char const*, int, GHashKey_wyHash<char const*>, GHashKey_Eq<char const*>, unsigned long>::Add(char const*, int)
inline int Add(const K ky, const V val) { // if a key does not exist allocate a copy of the key
		// return -1 if the key already exists
		int absent=-1;
		khInt_t i=this->put(ky, &absent);
		if (absent==1) { //key was actually added
			this->value(i)=val; //value is always copied
			return i;
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x12460
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x20(%rbp)
jne 0x10daa
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rsi
callq 0x124c0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x10db1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/./GVec.hh
// Function: GPVec<HStrData>::GPVec(int, bool)
GPVec<OBJ>::GPVec(int init_capacity, bool free_elements) {
  fCount=0;
  fCapacity=0;
  fList=nullptr;
  fFreeProc=(free_elements) ? DefaultFreeProc : NULL;
  if (init_capacity>0)
    setCapacity(init_capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x8c7b(%rip), %rcx      # 0x19d70
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movq $0x0, 0x8(%rax)
movb -0xd(%rbp), %sil
xorl %ecx, %ecx
leaq 0x2a11(%rip), %rdx      # 0x13b30
testb $0x1, %sil
cmovneq %rdx, %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, -0xc(%rbp)
jle 0x1113d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x11400
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gpertea[P]gclib/./GVec.hh
// Function: GPVec<HStrData>::setCapacity(int)
void GPVec<OBJ>::setCapacity(int NewCapacity) {
  if (NewCapacity < fCount || NewCapacity > MAXLISTSIZE)
    GError(GVEC_CAPACITY_ERR, NewCapacity);
    //error: capacity not within range
  if (NewCapacity!=fCapacity) {
   if (NewCapacity==0) {
      //GFREE(fList);
	   delete[] fList;
       fList=nullptr;
      }
    else {
      //GREALLOC(fList, NewCapacity*sizeof(OBJ*));
        OBJ** oldList=fList;
  	    fList=new OBJ*[NewCapacity];
        if (oldList) {
		   std::move(&oldList[0], &oldList[fCount], & fList[0]);
		   delete[] oldList;
        }
     }
   fCapacity=NewCapacity;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jl 0x11428
cmpl $0x7ffffffe, -0xc(%rbp) # imm = 0x7FFFFFFE
jle 0x11439
movl -0xc(%rbp), %esi
leaq 0x32c3(%rip), %rdi      # 0x146f5
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0x11500
cmpl $0x0, -0xc(%rbp)
jne 0x11478
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1146a
movq -0x28(%rbp), %rdi
callq 0x2320
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x114f6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x114f4
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq 0x10(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
callq 0x11510
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x114f2
movq -0x30(%rbp), %rdi
callq 0x2320
jmp 0x114f4
jmp 0x114f6
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)