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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xce6f(%rip), %rax      # 0x14250
movq %rax, 0x20(%rdi)
movq $0x0, (%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x71a2
testl %eax, %eax
js 0x7457
movl %eax, %r15d
movq %r12, %rdi
callq 0x2140
leal (%rax,%r15), %edx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x6442
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4e58
movq %rsp, %rdi
callq 0x4d60
movq %r14, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x694c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7475
movq %rax, %r14
movq %rsp, %rdi
callq 0x4d60
jmp 0x7478
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d60
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xcdb5(%rip), %rax      # 0x14250
movq %rax, 0x20(%rdi)
movq $0x0, (%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
testb %dl, %dl
je 0x7524
movq %rsi, %r14
movq 0x20(%rsi), %rax
movslq 0x8(%rax), %r15
testq %r15, %r15
jle 0x7524
cmpb %dl, 0xb(%rax,%r15)
je 0x74e5
decq %r15
leaq 0x1(%r15), %rcx
cmpq $0x2, %rcx
jae 0x74cf
jmp 0x7524
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x6442
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4e58
decq %r15
leaq 0x8(%rsp), %rdi
callq 0x4d60
movq %r14, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x694c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7542
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4d60
jmp 0x7545
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d60
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7570
callq 0x22e0
movq $0x0, (%r14)
testq %r15, %r15
je 0x75b5
movq %r15, %rdi
callq 0x2140
incq %rax
je 0x759c
movq %rax, %rdi
callq 0x2330
movq %rax, %rdi
movq %rax, (%r14)
testq %rax, %rax
jne 0x75ad
leaq 0x6a7d(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2220
movl $0x0, 0x8(%r14)
movl %ebx, 0xc(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2040
movq %rax, %r15
movl $0x0, (%rax)
movq 0x20(%r14), %rdi
addq $0xc, %rdi
movq %rsp, %rsi
movl %ebp, %edx
callq 0x2360
cmpl $0x0, (%r15)
je 0x7a87
xorl %eax, %eax
jmp 0x7a99
movq 0x20(%r14), %rcx
addq $0xc, %rcx
cmpq %rcx, (%rsp)
je 0x7a83
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2040
movq %rax, %r15
movl $0x0, (%rax)
movq 0x20(%r14), %rdi
addq $0xc, %rdi
leaq 0x8(%rsp), %rsi
callq 0x21d0
cmpl $0x0, (%r15)
je 0x7aed
xorl %eax, %eax
jmp 0x7b02
movq 0x20(%r14), %rax
addq $0xc, %rax
cmpq %rax, 0x8(%rsp)
je 0x7ae9
movsd %xmm0, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x55c4
testl %eax, %eax
js 0x7c9b
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %eax, %ecx
callq 0x6442
jmp 0x7cce
leaq 0xc5ae(%rip), %rax      # 0x14250
movq %rax, 0x20(%rbx)
movq $0x0, (%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x4a92
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
testb %dl, %dl
je 0x7d05
movslq 0x8(%rsi), %rcx
testq %rcx, %rcx
jle 0x7d05
cmpb %dl, 0xb(%rsi,%rcx)
je 0x7d39
decq %rcx
leaq 0x1(%rcx), %rdi
cmpq $0x2, %rdi
jae 0x7cf2
leaq 0xc544(%rip), %rax      # 0x14250
movq %rax, 0x20(%rbx)
movq $0x0, (%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x4a92
movq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
movq %rax, %rsi
movl %ecx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x6442
jmp 0x7d34
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x20(%rdi), %rcx
movslq 0x8(%rcx), %rdx
testq %rdx, %rdx
jle 0x7d77
xorl %edi, %edi
xorl %eax, %eax
xorl %r8d, %r8d
cmpb %sil, 0xc(%rcx,%rdi)
sete %r8b
addl %r8d, %eax
incq %rdi
cmpq %rdi, %rdx
jne 0x7d5f
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x2140
cmpl $0x2, %eax
jl 0x867e
cmpb $0x27, (%rbx)
jne 0x867e
leal -0x1(%rax), %ecx
cmpb $0x27, (%rbx,%rcx)
jne 0x867e
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq 0x1(%rbx), %rdx
movq %rdx, (%r14)
addl %ecx, %eax
movb $0x0, 0x1(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2978
movq %rax, %r14
movslq (%rbx), %r15
testq %r15, %r15
jle 0x86fa
movq 0x8(%rbx), %r12
xorl %ebx, %ebx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x86ee
movq %r14, %rsi
callq 0x2350
testl %eax, %eax
je 0x86ff
incq %rbx
addq $0x10, %r12
cmpq %rbx, %r15
jne 0x86d9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x870c
movq %r14, %rdi
callq 0x22e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x38(%rdi)
je 0x8774
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x8743
leaq 0x597f(%rip), %rsi      # 0xe0b8
movq %r14, %rdi
xorl %eax, %eax
callq 0x2370
movq 0x18(%r15), %rax
movslq 0x38(%r15), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x5ade(%rip), %rax      # 0xe234
leaq 0x5afe(%rip), %rsi      # 0xe25b
cmpb $0x0, 0x3c(%r15)
cmovneq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2370
testb %bl, %bl
jne 0x877a
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GArgs.cpp
// Function: GArgs::GArgs(int, char**, GArgsDef const*, bool)
GArgs::GArgs(int argc, char* argv[], const GArgsDef fmtrecs[], bool nodigitopts) {
 fmtcount=0;
 count=0;
 nonOptCount=0;
 nonOptPos=0;
 optPos=0;
 errarg=0;
 err_valmissing=false;
 args=NULL;
 fmt=NULL;
 _argc=argc;
 _argv=argv;
 if (fmtrecs==NULL) return;
 
 const GArgsDef* frec=fmtrecs;
 while ((frec->longopt || frec->opt) && fmtcount<255) {
     fmtcount++;
     frec=&(fmtrecs[fmtcount]);
     }
 GCALLOC(fmt, fmtcount*sizeof(fmtdef));
 for (int i=0;i<fmtcount;i++) {
   fmt[i].longopt=Gstrdup(fmtrecs[i].longopt); //do we need to use Gstrdup here?
   fmt[i].opt=fmtrecs[i].opt;
   fmt[i].req_value=fmtrecs[i].req_value;
   fmt[i].code=fmtrecs[i].code;
   }
 parseArgs(nodigitopts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x2d(%rdi)
movl %esi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
testq %rcx, %rcx
je 0x88f5
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x8(%rcx), %rax
xorl %r12d, %r12d
cmpq $0x0, -0x8(%rax)
je 0x884e
cmpq $0xfe, %r12
jbe 0x885c
jmp 0x8868
cmpb $0x0, (%rax)
je 0x8868
cmpq $0xff, %r12
jae 0x8868
incq %r12
movl %r12d, (%r15)
addq $0x10, %rax
jmp 0x883c
movl %r12d, %edi
shlq $0x4, %rdi
movl $0x1, %esi
callq 0x21c0
movq %rax, 0x8(%r15)
testq %rax, %rax
jne 0x8893
leaq 0x5797(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
movl (%r15), %r12d
testl %r12d, %r12d
jle 0x88e1
movl $0xc, %r12d
xorl %r13d, %r13d
movq -0xc(%r14,%r12), %rdi
xorl %esi, %esi
callq 0x2906
movq 0x8(%r15), %rcx
movq %rax, -0xc(%rcx,%r12)
movb -0x4(%r14,%r12), %al
movb %al, -0x4(%rcx,%r12)
movb -0x3(%r14,%r12), %al
movb %al, -0x3(%rcx,%r12)
movl (%r14,%r12), %eax
movl %eax, (%rcx,%r12)
incq %r13
movslq (%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x88a1
movzbl %bl, %esi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x8967
xorl %r12d, %r12d
leaq 0x5961(%rip), %r14      # 0xe27e
leaq 0x595e(%rip), %r15      # 0xe282
xorl %r13d, %r13d
movq 0x8(%rbx), %rbp
testq %rbp, %rbp
jne 0x8940
movq %r14, %rdi
movq %r15, %rsi
movl $0xf6, %edx
callq 0x282c
movq (%rbp,%r12), %rdi
testq %rdi, %rdi
je 0x894f
callq 0x22e0
movq $0x0, (%rbp,%r12)
incq %r13
movslq (%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x8927
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8975
callq 0x22e0
movq $0x0, 0x8(%rbx)
cmpl $0x0, 0x28(%rbx)
jle 0x89f4
xorl %r12d, %r12d
leaq 0x58f1(%rip), %r14      # 0xe27e
leaq 0x58ee(%rip), %r15      # 0xe282
xorl %r13d, %r13d
movq 0x20(%rbx), %rbp
testq %rbp, %rbp
jne 0x89b0
movq %r14, %rdi
movq %r15, %rsi
movl $0xf6, %edx
callq 0x282c
movq (%rbp,%r12), %rdi
testq %rdi, %rdi
je 0x89bf
callq 0x22e0
movq $0x0, (%rbp,%r12)
movq 0x20(%rbx), %rbp
movq 0x8(%rbp,%r12), %rdi
testq %rdi, %rdi
je 0x89db
callq 0x22e0
movq $0x0, 0x8(%rbp,%r12)
incq %r13
movslq 0x28(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x8997
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x8a02
callq 0x22e0
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8a1b
movq %rax, %rdi
callq 0x8c7a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x8a9a
movq %rsi, %r14
movq 0x20(%rdi), %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r15,%r13), %rdi
testq %rdi, %rdi
je 0x8a8f
movq %r14, %rsi
callq 0x2350
testl %eax, %eax
je 0x8a9e
addq $0x18, %r13
cmpq %r13, %r12
jne 0x8a7a
jmp 0x8aa3
xorl %ebx, %ebx
jmp 0x8aa3
movq 0x8(%r15,%r13), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x8ae8
movq 0x20(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %eax, %eax
xorl %edi, %edi
movq (%rcx,%rdi), %r8
testq %r8, %r8
je 0x8ade
cmpb %sil, (%r8)
jne 0x8ade
cmpb $0x0, 0x1(%r8)
je 0x8aeb
addq $0x18, %rdi
cmpq %rdi, %rdx
jne 0x8ac9
retq
xorl %eax, %eax
retq
movq 0x8(%rcx,%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x8b2f
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
xorl %eax, %eax
xorl %r8d, %r8d
movslq 0x10(%rcx,%r8), %r9
testq %r9, %r9
js 0x8b25
shlq $0x4, %r9
cmpl %esi, 0xc(%rdx,%r9)
je 0x8b32
addq $0x18, %r8
cmpq %r8, %rdi
jne 0x8b10
retq
xorl %eax, %eax
retq
movq 0x8(%rcx,%r8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x8b75
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
xorl %eax, %eax
xorl %r8d, %r8d
movslq 0x10(%rcx,%r8), %r9
testq %r9, %r9
js 0x8b6b
shlq $0x4, %r9
cmpl %esi, 0xc(%rdx,%r9)
je 0x8b78
addq $0x18, %r8
cmpq %r8, %rdi
jne 0x8b56
retq
xorl %eax, %eax
retq
movq (%rcx,%r8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x30(%rdi), %rcx
movslq 0x28(%rdi), %rax
cmpl %eax, %ecx
jge 0x8bc5
movq 0x20(%rdi), %rdx
leaq (%rcx,%rcx,2), %rsi
leaq (%rdx,%rsi,8), %rdx
addq $0x8, %rdx
movq %rcx, %rsi
subq %rax, %rsi
xorl %eax, %eax
xorl %r8d, %r8d
cmpq $0x0, -0x8(%rdx)
je 0x8bc8
decq %r8
addq $0x18, %rdx
cmpq %r8, %rsi
jne 0x8bb1
retq
xorl %eax, %eax
retq
subl %r8d, %ecx
incl %ecx
movl %ecx, 0x30(%rdi)
movq (%rdx), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x34(%rdi), %rcx
movslq 0x28(%rdi), %rax
cmpl %eax, %ecx
jge 0x8c17
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq 0x20(%rdi), %rdx
movq %rcx, %rsi
subq %rax, %rsi
xorl %r8d, %r8d
movq (%rdx), %rax
testq %rax, %rax
jne 0x8c1a
decq %r8
addq $0x18, %rdx
cmpq %r8, %rsi
jne 0x8c03
xorl %eax, %eax
retq
subl %r8d, %ecx
incl %ecx
movl %ecx, 0x34(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x34(%rdi), %rdx
movl 0x28(%rdi), %ecx
xorl %eax, %eax
cmpl %ecx, %edx
jge 0x8c68
movq 0x20(%rdi), %r8
leal 0x1(%rdx), %esi
leaq (%rdx,%rdx,2), %rdx
leaq (%r8,%rdx,8), %rdx
addq $0x10, %rdx
negl %ecx
cmpq $0x0, -0x10(%rdx)
je 0x8c55
movslq (%rdx), %r8
testq %r8, %r8
jns 0x8c69
addq $0x18, %rdx
leal (%rcx,%rsi), %r8d
incl %r8d
incl %esi
cmpl $0x1, %r8d
jne 0x8c46
retq
movl %esi, 0x34(%rdi)
movq 0x8(%rdi), %rax
shlq $0x4, %r8
movl 0xc(%rax,%r8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movw $0x1, (%rdi)
callq 0x8cae
movq %rax, %xmm1
punpckldq 0x54d3(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x8(%rbx)
subpd 0x54d7(%rip), %xmm1     # 0xe2a0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x5513(%rip), %xmm0     # 0xe2f0
leaq 0x5554(%rip), %rdi      # 0xe338
movb $0x1, %al
callq 0x2470
leaq 0x18(%rbx), %rsi
xorl %edi, %edi
callq 0x21a0
leaq 0x138(%rbx), %rsi
movl $0x1, %edi
callq 0x2210
xorps %xmm0, %xmm0
cvtsi2sdq 0x138(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x140(%rbx), %xmm1
divsd 0x54d1(%rip), %xmm1     # 0xe2f8
mulsd 0x54d1(%rip), %xmm0     # 0xe300
addsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x8e51
leaq 0x5501(%rip), %rdi      # 0xe34b
xorl %eax, %eax
callq 0x286c
movb $0x1, 0x1(%rbx)
leaq 0x148(%rbx), %rsi
movl $0x1, %edi
callq 0x2210
leaq 0xa8(%rbx), %rsi
xorl %edi, %edi
callq 0x21a0
cvtsi2sdq 0x148(%rbx), %xmm1
cvtsi2sdq 0x150(%rbx), %xmm0
divsd 0x546a(%rip), %xmm0     # 0xe2f8
mulsd 0x546a(%rip), %xmm1     # 0xe300
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x8cae
movq %rax, %xmm1
punpckldq 0x53de(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rbx)
subpd 0x53e2(%rip), %xmm1     # 0xe2a0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x541e(%rip), %xmm0     # 0xe2f0
leaq 0x54af(%rip), %rdi      # 0xe388
movb $0x1, %al
callq 0x2470
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x8f15
cmpb $0x0, 0x1(%rbx)
jne 0x8f2a
leaq 0x547e(%rip), %rdi      # 0xe39a
leaq 0x54bc(%rip), %rsi      # 0xe3df
xorl %eax, %eax
callq 0x286c
cvtsi2sdq 0x138(%rbx), %xmm1
cvtsi2sdq 0x140(%rbx), %xmm2
movsd 0x53b4(%rip), %xmm3     # 0xe2f8
divsd %xmm3, %xmm2
movsd 0x53b0(%rip), %xmm4     # 0xe300
mulsd %xmm4, %xmm1
cvtsi2sdq 0x148(%rbx), %xmm0
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtsi2sdq 0x150(%rbx), %xmm2
divsd %xmm3, %xmm2
mulsd %xmm4, %xmm0
addsd %xmm2, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x8f8f
cmpb $0x0, 0x1(%rbx)
jne 0x8fa4
leaq 0x5404(%rip), %rdi      # 0xe39a
leaq 0x5436(%rip), %rsi      # 0xe3d3
xorl %eax, %eax
callq 0x286c
cvtsi2sdq 0x18(%rbx), %xmm1
cvtsi2sdq 0x20(%rbx), %xmm0
movsd 0x5348(%rip), %xmm2     # 0xe300
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0xa8(%rbx), %xmm0
cvtsi2sdq 0xb0(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x8ff3
cmpb $0x0, 0x1(%rbx)
jne 0x9008
leaq 0x53a0(%rip), %rdi      # 0xe39a
leaq 0x53dc(%rip), %rsi      # 0xe3dd
xorl %eax, %eax
callq 0x286c
cvtsi2sdq 0x28(%rbx), %xmm1
cvtsi2sdq 0x30(%rbx), %xmm0
movsd 0x52e4(%rip), %xmm2     # 0xe300
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0xb8(%rbx), %xmm0
cvtsi2sdq 0xc0(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x8f06
cvttsd2si %xmm0, %rax
subsd 0x5042(%rip), %xmm0     # 0xe3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x4490
movq %rax, %rbx
movq %r12, %rdi
callq 0x8f80
cvttsd2si %xmm0, %rax
subsd 0x5013(%rip), %xmm0     # 0xe3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x4490
movq %rax, %r14
movq %r12, %rdi
callq 0x8fe4
cvttsd2si %xmm0, %rax
subsd 0x4fe4(%rip), %xmm0     # 0xe3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x4490
movq %rax, %r15
movq %r12, %rdi
callq 0x9048
cvttsd2si %xmm0, %rax
subsd 0x4fb5(%rip), %xmm0     # 0xe3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x4490
movq %rax, %r12
leaq 0x5035(%rip), %rdi      # 0xe499
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x504a(%rip), %rdi      # 0xe4bf
movq %r14, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x505f(%rip), %rdi      # 0xe4e5
movq %r15, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x5074(%rip), %rdi      # 0xe50b
movq %r12, %rsi
xorl %eax, %eax
callq 0x2470
testq %rbx, %rbx
je 0x94ae
movq %rbx, %rdi
callq 0x22e0
testq %r14, %r14
je 0x94bb
movq %r14, %rdi
callq 0x22e0
testq %r15, %r15
je 0x94c8
movq %r15, %rdi
callq 0x22e0
testq %r12, %r12
je 0x94d5
movq %r12, %rdi
callq 0x22e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0xaceb
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movslq %eax, %r15
cmpl 0x14(%rdi), %r15d
jne 0xacd7
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x9, %eax
movl $0x1, %esi
cmovgel %ecx, %esi
addl %eax, %esi
movq %rbx, %rdi
callq 0xb8f2
movl 0x10(%rbx), %eax
movq 0x8(%rbx), %rcx
movq %r14, (%rcx,%r15,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x9013(%rip), %rax      # 0x13d50
movq %rax, (%rdi)
movl $0x300, %edi            # imm = 0x300
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xad65
leaq 0x32c6(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
movq 0x8(%rbx), %rax
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
leaq 0xb57(%rip), %rdx       # 0xb8d0
testb %bpl, %bpl
cmoveq %rcx, %rdx
movq %rdx, 0x28(%rbx)
movl $0xc, %ecx
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
addq $0x18, %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
jne 0xad89
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0xae11
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %r12
cmpl $0x0, 0xc(%r12,%r14)
js 0xae01
cmpb $0x1, 0x8(%r12,%r14)
jne 0xaded
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0xade5
callq 0x22e0
movq $0x0, (%r12,%r14)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xae01
movq 0x8(%rbx), %rcx
movq 0x10(%rcx,%r14), %rdi
callq *%rax
incq %r15
movslq 0x10(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0xadc3
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xae1f
callq 0x22e0
movl $0x300, %edi            # imm = 0x300
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xae44
leaq 0x31e7(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
movq 0x8(%rbx), %rax
movl $0xc, %ecx
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
addq $0x18, %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
jne 0xae49
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x89fc(%rip), %rax      # 0x13d50
movq %rax, (%rdi)
cmpl $0x0, 0x10(%rdi)
jle 0xb3b1
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %r12
cmpl $0x0, 0xc(%r12,%r14)
js 0xb3a1
cmpb $0x1, 0x8(%r12,%r14)
jne 0xb38d
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0xb385
callq 0x22e0
movq $0x0, (%r12,%r14)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xb3a1
movq 0x8(%rbx), %rcx
movq 0x10(%rcx,%r14), %rdi
callq *%rax
incq %r15
movslq 0x10(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0xb363
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb3bf
callq 0x22e0
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x8c7a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0xb90a
cmpl %ebx, 0x10(%r14)
jle 0xb91a
leaq 0x2e44(%rip), %rdi      # 0xe755
movl %ebx, %esi
xorl %eax, %eax
callq 0x286c
cmpl %ebx, 0x14(%r14)
je 0xb984
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0xb96b
movl %ebx, %eax
shlq $0x3, %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0xb980
movslq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0xb961
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x23c0
movq %r15, %rdi
callq 0x2320
jmp 0xb980
testq %r15, %r15
je 0xb978
movq %r15, %rdi
callq 0x2320
movq $0x0, 0x8(%r14)
movl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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>::get(klib::KHashMapCachedBucket<char const*, int, unsigned int> const&) const
khint_t get(const T &key) const {
		khint_t i, last, mask, nb;
		if (keys == 0) return 0;
		nb = n_buckets();
		mask = nb - khint_t(1);
		i = last = __kh_h2b(Hash()(key), bits);
		while (__kh_used(used, i) && !Eq()(keys[i], key)) {
			i = (i + khint_t(1)) & mask;
			if (i == last) return nb;
		}
		return !__kh_used(used, i)? nb : i;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0xc250
movq 0x8(%rdi), %r12
movb (%rdi), %cl
movl $0x1, %eax
shll %cl, %eax
xorl %edx, %edx
testq %r12, %r12
cmovnel %eax, %edx
movl 0xc(%rsi), %ebp
imull $0x9e3779b9, %ebp, %r14d # imm = 0x9E3779B9
negb %cl
shrl %cl, %r14d
movq %rdx, 0x8(%rsp)
leal -0x1(%rdx), %ebx
movq (%rsi), %rax
movq %rax, 0x10(%rsp)
movl %r14d, %r13d
movl %r13d, %eax
shrl $0x5, %eax
movl (%r12,%rax,4), %eax
btl %r13d, %eax
jae 0xc249
movl %r13d, %eax
shlq $0x4, %rax
cmpl %ebp, 0xc(%r15,%rax)
jne 0xc23e
addq %r15, %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2350
testl %eax, %eax
je 0xc254
incl %r13d
andl %ebx, %r13d
cmpl %r14d, %r13d
jne 0xc20c
movq 0x8(%rsp), %rax
jmp 0xc257
xorl %eax, %eax
jmp 0xc257
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/./GVec.hh
// Function: GPVec<HStrData>::Clear()
void GPVec<OBJ>::Clear() {
 if (FREEDATA) {
   for (int i=0; i<fCount; i++) {
     (*fFreeProc)(fList[i]);
     }
   }
 //GFREE(fList);
 delete[] fList;
 fList=nullptr;
 fCount=0;
 fCapacity=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0xd054
cmpl $0x0, 0x10(%rbx)
jle 0xd054
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq *0x18(%rbx)
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0xd03d
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0xd066
callq 0x2320
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/struthj[P]Python-to-C-transpiler/parser-push.cpp
// Function: yypstate_new()
yypstate *
yypstate_new (void)
{
  yypstate *yyps;
  yyps = YY_CAST (yypstate *, YYMALLOC (sizeof *yyps));
  if (!yyps)
    return YY_NULLPTR;
  yystacksize = YYINITDEPTH;
  yyss = yyssa;
  yyvs = yyvsa;
  yyls = yylsa;
  yypstate_clear (yyps);
  return yyps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x13d8, %edi           # imm = 0x13D8
callq 0x21d0
testq %rax, %rax
je 0x3012
movq $0xc8, 0x10(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0xe0(%rax)
leaq 0xf0(%rax), %rdx
movq %rdx, 0x730(%rax)
movq %rax, %rsi
addq $0x740, %rsi            # imm = 0x740
movq %rsi, 0x13c0(%rax)
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movq %rcx, 0xe8(%rax)
movq %rdx, 0x738(%rax)
movq %rsi, 0x13c8(%rax)
movb $0x0, 0x18(%rax)
movl $0x1, 0x13d0(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/struthj[P]Python-to-C-transpiler/parser-push.cpp
// Function: yypstate_delete(yypstate*)
void
yypstate_delete (yypstate *yyps)
{
  if (yyps)
    {
#ifndef yyoverflow
      /* If the stack was reallocated but the parse did not complete, then the
         stack still needs to be freed.  */
      if (yyss != yyssa)
        YYSTACK_FREE (yyss);
#endif
      YYFREE (yyps);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3045
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe0(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x3037
callq 0x21b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b0
retq
// File: /workspace/github_cpp_makefile_star2_O3/struthj[P]Python-to-C-transpiler/scanner-push.cpp
// Function: yy_get_previous_state()
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);
	yy_current_state += YY_AT_BOL();

	(yy_state_ptr) = (yy_state_buf);
	*(yy_state_ptr)++ = yy_current_state;

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 172 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		*(yy_state_ptr)++ = yy_current_state;
		}

	return yy_current_state;
}

// Assembly:
movzbl 0x517b(%rip), %eax      # 0xb290
movq 0x517c(%rip), %rcx      # 0xb298
movq 0x517d(%rip), %rdx      # 0xb2a0
movq (%rcx,%rdx,8), %rcx
addl 0x28(%rcx), %eax
movq 0x5157(%rip), %rdx      # 0xb288
leaq 0x4(%rdx), %rcx
movq %rcx, 0x517c(%rip)      # 0xb2b8
movl %eax, (%rdx)
movq 0x50bb(%rip), %rdx      # 0xb200
movq 0x515c(%rip), %rsi      # 0xb2a8
cmpq %rsi, %rdx
jae 0x61fe
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x17a7(%rip), %rdi      # 0x7910
leaq 0x1550(%rip), %r8       # 0x76c0
leaq 0x1aa9(%rip), %r9       # 0x7c20
leaq 0x1902(%rip), %r10      # 0x7a80
leaq 0x1a6b(%rip), %r11      # 0x7bf0
leaq 0x1434(%rip), %rbx      # 0x75c0
movzbl (%rdx), %r14d
testq %r14, %r14
je 0x619b
movb (%r14,%rbx), %r14b
jmp 0x619e
movb $0x1, %r14b
cltq
movswq (%rdi,%rax,2), %r12
movzbl %r14b, %r15d
addq %r15, %r12
movswl (%r8,%r12,2), %r13d
cmpl %r13d, %eax
je 0x61da
movswq (%r10,%rax,2), %rax
cmpq $0xac, %rax
jl 0x61c7
movb (%r15,%r11), %r14b
movswq (%rdi,%rax,2), %r12
movzbl %r14b, %r15d
addq %r15, %r12
cmpw (%r8,%r12,2), %ax
jne 0x61b6
movswl (%r9,%r12,2), %eax
movl %eax, (%rcx)
addq $0x4, %rcx
incq %rdx
cmpq %rsi, %rdx
jne 0x618c
movq %rcx, 0x50c4(%rip)      # 0xb2b8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/calculate-routing-metrics.cc
// Function: PrintSimulationOptions(SimulationOptions const&)
void PrintSimulationOptions(const SimulationOptions& options) {
  printf("SimulationOptions:\n");
  printf("num_sensors = %d\n", options.num_sensors);
  printf("times = %d\n", options.times);
  printf("region.min_x = %f\n", options.region.min_x);
  printf("region.min_y = %f\n", options.region.min_y);
  printf("region.max_x = %f\n", options.region.max_x);
  printf("region.max_y = %f\n", options.region.max_y);
  printf("lower_communication_range = %f\n", options.lower_communication_range);
  printf("upper_communication_range = %f\n", options.upper_communication_range);
  printf("communication_range_step = %f\n", options.communication_range_step);
  printf("\n");
  printf("Routing Building Algorithms:\n");
  for (int i = 0; i < options.builders.size(); i++) {
    printf("%s\n", options.builders[i]->name().c_str());
  }
  printf("\n");
  printf("Routing Metrics:\n");
  for (int i = 0; i < options.calculators.size(); i++) {
    printf("%s\n", options.calculators[i]->name().c_str());
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8bed(%rip), %rdi      # 0xc2d7
callq 0x32d0
movl (%rbx), %esi
leaq 0x8948(%rip), %rdi      # 0xc040
xorl %eax, %eax
callq 0x3040
movl 0x4(%rbx), %esi
leaq 0x8949(%rip), %rdi      # 0xc052
xorl %eax, %eax
callq 0x3040
movsd 0x8(%rbx), %xmm0
leaq 0x8942(%rip), %rdi      # 0xc05e
movb $0x1, %al
callq 0x3040
movsd 0x10(%rbx), %xmm0
leaq 0x8942(%rip), %rdi      # 0xc071
movb $0x1, %al
callq 0x3040
movsd 0x18(%rbx), %xmm0
leaq 0x8942(%rip), %rdi      # 0xc084
movb $0x1, %al
callq 0x3040
movsd 0x20(%rbx), %xmm0
leaq 0x8942(%rip), %rdi      # 0xc097
movb $0x1, %al
callq 0x3040
movsd 0x28(%rbx), %xmm0
leaq 0x8942(%rip), %rdi      # 0xc0aa
movb $0x1, %al
callq 0x3040
movsd 0x30(%rbx), %xmm0
leaq 0x894f(%rip), %rdi      # 0xc0ca
movb $0x1, %al
callq 0x3040
movsd 0x38(%rbx), %xmm0
leaq 0x895c(%rip), %rdi      # 0xc0ea
movb $0x1, %al
callq 0x3040
movl $0xa, %edi
callq 0x3280
leaq 0x8b44(%rip), %rdi      # 0xc2ea
callq 0x32d0
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x37dc
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
callq 0x32d0
incq %r14
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x37b8
movl $0xa, %edi
callq 0x3280
leaq 0x8b1a(%rip), %rdi      # 0xc307
callq 0x32d0
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0x3823
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
callq 0x32d0
incq %r14
movq 0x58(%rbx), %rax
movq 0x60(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x37ff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/calculate-routing-metrics.cc
// Function: RoutingMetrics::AddData(double, int, int, double)
void AddData(double range, int builder, int calculator, double metric) {
    assert(data_.find(range) != data_.end());
    std::pair<double, int>& p = data_[range][builder][calculator];
    p.first += metric;
    p.second++;
  }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x4af8
movl %edx, %ebx
movl %esi, %ebp
leaq 0x78(%rdi), %rdx
movq %rdx, %rcx
xorl %esi, %esi
ucomisd 0x20(%rax), %xmm0
cmovbeq %rax, %rcx
seta %sil
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x4a91
cmpq %rdx, %rcx
je 0x4af8
movsd 0x20(%rcx), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4af8
addq $0x70, %rdi
leaq 0x10(%rsp), %rsi
callq 0x508c
movslq %ebp, %rcx
movq (%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movslq %ebx, %rdx
movq (%rax,%rcx,8), %rax
shlq $0x4, %rdx
movsd 0x8(%rsp), %xmm0
addsd (%rax,%rdx), %xmm0
movsd %xmm0, (%rax,%rdx)
incl 0x8(%rax,%rdx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x76d6(%rip), %rdi      # 0xc1d5
leaq 0x76f0(%rip), %rsi      # 0xc1f6
leaq 0x7706(%rip), %rcx      # 0xc213
movl $0x67, %edx
callq 0x3100
nop
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/routing-metric-calculators.cc
// Function: SortSensorsByUsage(SensorNetwork const&, std::vector<int, std::allocator<int>>*)
void SortSensorsByUsage(const SensorNetwork& network,
                        std::vector<int>* sorted_sensors) {
  std::vector<SensorUsage> usages(network.num_sensors());
  for (int i = 0; i < usages.size(); i++) {
    usages[i].sensor = i;
    usages[i].usage = 1;  // Every sensor is used by itself.
  }

  for (int i = 0; i < network.num_sensors(); i++) {
    int parent = network.GetParent(i);
    while (parent >= 0) {
      usages[parent].usage++;
      parent = network.GetParent(parent);
    }
  }

  std::sort(usages.begin(), usages.end(), std::greater<SensorUsage>());

  sorted_sensors->resize(usages.size());
  for (int i = 0; i < usages.size(); i++) {
    (*sorted_sensors)[i] = usages[i].sensor;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %rbx
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
movslq %eax, %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0xb034
movq (%r14), %r15
movq 0x8(%r14), %r14
movq %r14, %rax
subq %r15, %rax
sarq $0x3, %rax
cmpq %r15, %r14
je 0xa0f5
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movl %edx, (%r15,%rdx,8)
movl $0x1, 0x4(%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0xa0e0
movq (%r12), %rcx
movq 0x8(%r12), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rsi, %rdx
testl %edx, %edx
jle 0xa140
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
leaq (%rsi,%rsi,8), %rdi
movl 0x44(%rcx,%rdi,8), %edi
testl %edi, %edi
js 0xa138
movl %edi, %edi
incl 0x4(%r15,%rdi,8)
leaq (%rdi,%rdi,8), %rdi
jmp 0xa123
incq %rsi
cmpq %rdx, %rsi
jne 0xa11f
cmpq %r15, %r14
je 0xa174
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb2c3
movq %r15, %rdi
movq %r14, %rsi
callq 0xb3c1
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rsi
jmp 0xa177
movq %r14, %rsi
subq %r14, %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0xb172
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
je 0xa1b6
sarq $0x3, %rax
movq (%rbx), %rcx
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
movl (%rdi,%rdx,8), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0xa1a6
jmp 0xa1bb
testq %rdi, %rdi
je 0xa1c8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x31e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa1ee
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x31e0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::~OptimalSolverLN()
OptimalSolverLN::~OptimalSolverLN() {
	if  (matrix != NULL) {
		delete [] matrix;
		matrix = NULL;
	}
	if  (base != NULL) {
		delete [] base;
		base = NULL;
	}
	if  (defaultMatrix != NULL) {
		delete [] defaultMatrix;
		defaultMatrix = NULL;
	}
	if  (defaultBase != NULL) {
		delete [] defaultBase;
		defaultBase = NULL;
	}

	if (level.size() != 0)
		level.clear();
	if (level0.size() != 0)
		level0.clear();
	if (seeds.size() != 0)
		seeds.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x370(%rdi), %rdi
testq %rdi, %rdi
je 0x4606
callq 0x3340
movq $0x0, 0x370(%rbx)
movq 0x378(%rbx), %rdi
testq %rdi, %rdi
je 0x4622
callq 0x3340
movq $0x0, 0x378(%rbx)
movq 0x3b0(%rbx), %rdi
testq %rdi, %rdi
je 0x463e
callq 0x3340
movq $0x0, 0x3b0(%rbx)
movq 0x3b8(%rbx), %rdi
testq %rdi, %rdi
je 0x465a
callq 0x3340
movq $0x0, 0x3b8(%rbx)
movq 0x380(%rbx), %rax
cmpq %rax, 0x388(%rbx)
je 0x4671
movq %rax, 0x388(%rbx)
movq 0x398(%rbx), %rax
cmpq %rax, 0x3a0(%rbx)
je 0x4688
movq %rax, 0x3a0(%rbx)
movq 0x3c8(%rbx), %rdi
cmpq %rdi, 0x3d0(%rbx)
je 0x469f
movq %rdi, 0x3d0(%rbx)
movq 0x3e8(%rbx), %rax
testq %rax, %rax
je 0x46c4
movq 0x3f8(%rbx), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x3290
movq 0x3c8(%rbx), %rdi
testq %rdi, %rdi
je 0x46d8
movq 0x3d8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
movq 0x398(%rbx), %rdi
testq %rdi, %rdi
je 0x46f3
movq 0x3a8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
movq 0x380(%rbx), %rdi
testq %rdi, %rdi
je 0x470e
movq 0x390(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7dc6
nop
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::feedL0()
void OptimalSolverLN::feedL0() {
	reset();
	tree.setHashLength(10);
	int lvPosCount = readLength + 1 - minLength;

	for (int i = 0; i < lvPosCount; i++) {
		for (int j = 0; j < lvPosCount - i; j++) {
			cin >> level0[i][j].start;
			cin >> level0[i][j].end;
			cin >> level0[i][j].frequency;
			cin >> level0[i][j].isleaf;
#ifdef DEBUG
			cout << "level0[" << i << "][" << j << "]:" << level0[i][j].start << "-" 
				<<level0[i][j].end << ":" << level0[i][j].frequency << " ";
			cout.flush();
		}
		cout << endl;
#else
		}
#endif

	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x370(%rdi), %rdi
movq 0x3b0(%rbx), %rsi
movslq 0x3c0(%rbx), %rdx
callq 0x3200
movq 0x378(%rbx), %rdi
movq 0x3b8(%rbx), %rsi
movslq 0x3c4(%rbx), %rdx
callq 0x3200
movl $0xa, 0x8(%rbx)
movl 0x360(%rbx), %eax
subl 0x368(%rbx), %eax
incl %eax
testl %eax, %eax
jle 0x4d0f
movl %eax, %r13d
xorl %r12d, %r12d
movq 0xc35a(%rip), %r14      # 0x10fd8
movq %r13, (%rsp)
subq %r12, %r13
jle 0x4cff
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x3470
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%rbp), %rsi
addq $0x4, %rsi
movq %r14, %rdi
callq 0x3470
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%rbp), %rsi
addq $0xc, %rsi
movq %r14, %rdi
callq 0x3470
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%rbp), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x3220
incq %r15
addq $0x28, %rbp
cmpq %r13, %r15
jl 0x4c8c
incq %r12
movq (%rsp), %r13
cmpq %r13, %r12
jne 0x4c82
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop