LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, (%rdi)
andq $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 0x800d
movl %r8d, %ebx
movq %rdi, %r14
movq %rcx, %r15
leaq 0x8(%rdi), %r12
leaq 0x8(%rcx), %rax
xorl %esi, %esi
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %edx, %edx
cmpq $0x0, -0x8(%rax)
je 0x7f71
cmpq $0xfe, %rdx
jbe 0x7f7f
jmp 0x7f8e
cmpb $0x0, (%rax)
je 0x7f8e
cmpq $0xff, %rdx
jae 0x7f8e
incq %rdx
movl %edx, (%r14)
addq %rcx, %rsi
addq $0x10, %rax
jmp 0x7f5f
sarq $0x1c, %rsi
movq %r12, %rdi
callq 0x82bd
testb %al, %al
jne 0x7fac
leaq 0x407b(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
pushq $0xc
popq %r13
xorl %ebp, %ebp
movslq (%r14), %rax
cmpq %rax, %rbp
jge 0x7ff4
movq -0xc(%r15,%r13), %rdi
xorl %esi, %esi
callq 0x2704
movq (%r12), %rcx
movq %rax, -0xc(%rcx,%r13)
movb -0x4(%r15,%r13), %al
movb %al, -0x4(%rcx,%r13)
movb -0x3(%r15,%r13), %al
movb %al, -0x3(%rcx,%r13)
movl (%r15,%r13), %eax
movl %eax, (%rcx,%r13)
incq %rbp
addq $0x10, %r13
jmp 0x7fb2
movzbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7878
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x804d
movq (%r14), %rdi
addq %r15, %rdi
callq 0x420d
incq %r12
addq $0x10, %r15
jmp 0x8031
movq %r14, %rdi
callq 0x420d
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x28(%rbx), %rax
cmpq %rax, %r12
jge 0x808c
movq (%r14), %rdi
addq %r15, %rdi
callq 0x420d
movq (%r14), %rax
leaq (%rax,%r15), %rdi
addq $0x8, %rdi
callq 0x420d
incq %r12
addq $0x18, %r15
jmp 0x805f
movq %r14, %rdi
callq 0x420d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x80a4
jmp 0x80a4
movq %rax, %rdi
callq 0x765e
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
movl 0x28(%rdi), %eax
movq 0x20(%rdi), %r15
xorl %ebx, %ebx
testl %eax, %eax
cmovlel %ebx, %eax
imulq $0x18, %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x8120
movq (%r15,%r13), %rdi
testq %rdi, %rdi
je 0x8115
movq %r14, %rsi
callq 0x2350
testl %eax, %eax
je 0x811b
addq $0x18, %r13
jmp 0x80fb
movq 0x8(%r15,%r13), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x28(%rdi), %edx
movq 0x20(%rdi), %rcx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
imulq $0x18, %rdx, %rdx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x8167
movq (%rcx,%rdi), %r8
testq %r8, %r8
je 0x815c
cmpb %sil, (%r8)
jne 0x815c
cmpb $0x0, 0x1(%r8)
je 0x8162
addq $0x18, %rdi
jmp 0x8142
movq 0x8(%rcx,%rdi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x28(%rdi), %r8d
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
imulq $0x18, %r8, %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x81a9
movslq 0x10(%rcx,%r8), %r9
testq %r9, %r9
js 0x819e
shlq $0x4, %r9
cmpl %esi, 0xc(%rdx,%r9)
je 0x81a4
addq $0x18, %r8
jmp 0x8184
movq 0x8(%rcx,%r8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x28(%rdi), %r8d
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
imulq $0x18, %r8, %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x81ea
movslq 0x10(%rcx,%r8), %r9
testq %r9, %r9
js 0x81e0
shlq $0x4, %r9
cmpl %esi, 0xc(%rdx,%r9)
je 0x81e6
addq $0x18, %r8
jmp 0x81c6
movq (%rcx,%r8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
movq 0x20(%rdi), %rax
imulq $0x18, %rcx, %rsi
addq %rax, %rsi
addq $0x8, %rsi
leal 0x1(%rcx), %r8d
xorl %eax, %eax
cmpq %rdx, %rcx
jge 0x8230
cmpq $0x0, -0x8(%rsi)
je 0x8229
incq %rcx
addq $0x18, %rsi
incl %r8d
jmp 0x8211
movl %r8d, 0x30(%rdi)
movq (%rsi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
leal 0x1(%rcx), %esi
imulq $0x18, %rcx, %r8
addq 0x20(%rdi), %r8
cmpq %rdx, %rcx
jge 0x8269
movq (%r8), %rax
testq %rax, %rax
jne 0x826c
incq %rcx
incl %esi
addq $0x18, %r8
jmp 0x8251
xorl %eax, %eax
retq
movl %esi, 0x34(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movslq 0x28(%rdi), %rcx
movq 0x20(%rdi), %rsi
leal 0x1(%rax), %edx
imulq $0x18, %rax, %r8
addq %r8, %rsi
addq $0x10, %rsi
cmpq %rcx, %rax
jge 0x82a9
cmpq $0x0, -0x10(%rsi)
je 0x829e
movslq (%rsi), %r8
testq %r8, %r8
jns 0x82ac
incq %rax
incl %edx
addq $0x18, %rsi
jmp 0x828a
xorl %eax, %eax
retq
movl %edx, 0x34(%rdi)
movq 0x8(%rdi), %rax
shlq $0x4, %r8
movl 0xc(%rax,%r8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8326
movq %rax, %xmm1
punpckldq 0x3e61(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x8(%rbx)
subpd 0x3e65(%rip), %xmm1     # 0xc2a0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x3ea1(%rip), %xmm0     # 0xc2f0
leaq 0x3ee2(%rip), %rdi      # 0xc338
movb $0x1, %al
callq 0x2662
leaq 0x18(%rbx), %rsi
xorl %edi, %edi
callq 0x21a0
leaq 0x138(%rbx), %rsi
pushq $0x1
popq %rdi
callq 0x2210
cvtsi2sdq 0x138(%rbx), %xmm0
cvtsi2sdq 0x140(%rbx), %xmm1
divsd 0x3e67(%rip), %xmm1     # 0xc2f8
mulsd 0x3e67(%rip), %xmm0     # 0xc300
addsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x84bb
leaq 0x3e97(%rip), %rdi      # 0xc34b
xorl %eax, %eax
callq 0x25ca
movb $0x1, 0x1(%rbx)
leaq 0x148(%rbx), %rsi
pushq $0x1
popq %rdi
callq 0x2210
leaq 0xa8(%rbx), %rsi
xorl %edi, %edi
callq 0x21a0
cvtsi2sdq 0x148(%rbx), %xmm1
cvtsi2sdq 0x150(%rbx), %xmm0
divsd 0x3e02(%rip), %xmm0     # 0xc2f8
mulsd 0x3e02(%rip), %xmm1     # 0xc300
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x8326
movq %rax, %xmm1
punpckldq 0x3d76(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rbx)
subpd 0x3d7a(%rip), %xmm1     # 0xc2a0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x3db6(%rip), %xmm0     # 0xc2f0
leaq 0x3e47(%rip), %rdi      # 0xc388
movb $0x1, %al
callq 0x2662
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x3e66(%rip), %rsi      # 0xc3df
callq 0x8554
cvtsi2sdq 0x138(%rbx), %xmm1
cvtsi2sdq 0x140(%rbx), %xmm2
movsd 0x3d60(%rip), %xmm3     # 0xc2f8
divsd %xmm3, %xmm2
movsd 0x3d5c(%rip), %xmm4     # 0xc300
mulsd %xmm4, %xmm1
cvtsi2sdq 0x148(%rbx), %xmm0
addsd %xmm2, %xmm1
cvtsi2sdq 0x150(%rbx), %xmm2
divsd %xmm3, %xmm2
mulsd %xmm4, %xmm0
addsd %xmm2, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x3df8(%rip), %rsi      # 0xc3d3
callq 0x8554
cvtsi2sdq 0x18(%rbx), %xmm1
cvtsi2sdq 0x20(%rbx), %xmm0
movsd 0x3d0c(%rip), %xmm2     # 0xc300
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0xa8(%rbx), %xmm0
cvtsi2sdq 0xb0(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x3db6(%rip), %rsi      # 0xc3dd
callq 0x8554
cvtsi2sdq 0x28(%rbx), %xmm1
cvtsi2sdq 0x30(%rbx), %xmm0
movsd 0x3cc0(%rip), %xmm2     # 0xc300
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0xb8(%rbx), %xmm0
cvtsi2sdq 0xc0(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
movq %r15, %rdi
callq 0x856e
cvttsd2si %xmm0, %rax
subsd 0x3af7(%rip), %xmm0     # 0xc3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x40f9
movq %rax, %rbx
movq %r15, %rdi
callq 0x85d0
cvttsd2si %xmm0, %rax
subsd 0x3ac8(%rip), %xmm0     # 0xc3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x40f9
movq %rax, %r14
movq %r15, %rdi
callq 0x861c
cvttsd2si %xmm0, %rax
subsd 0x3a99(%rip), %xmm0     # 0xc3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x40f9
movq %rax, %r12
movq %r15, %rdi
callq 0x8668
cvttsd2si %xmm0, %rax
subsd 0x3a6a(%rip), %xmm0     # 0xc3f8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x40f9
movq %rax, %r15
leaq 0x3a9a(%rip), %rdi      # 0xc449
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2662
leaq 0x3aaf(%rip), %rdi      # 0xc46f
movq %r14, %rsi
xorl %eax, %eax
callq 0x2662
leaq 0x3ac4(%rip), %rdi      # 0xc495
movq %r12, %rsi
xorl %eax, %eax
callq 0x2662
leaq 0x3ad9(%rip), %rdi      # 0xc4bb
movq %r15, %rsi
xorl %eax, %eax
callq 0x2662
movq %rbx, %rdi
callq 0x22e0
movq %r14, %rdi
callq 0x22e0
movq %r12, %rdi
callq 0x22e0
movq %r15, %rdi
callq 0x22e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9b63
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movslq %eax, %r15
cmpl 0x14(%rdi), %r15d
jne 0x9b4f
movq %rbx, %rdi
callq 0xa652
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
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x81ab(%rip), %rax      # 0x11d50
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x300, %esi            # imm = 0x300
callq 0x415c
testb %al, %al
jne 0x9bc8
leaq 0x245f(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
orl $-0x1, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0xa5c(%rip), %rax       # 0xa634
xorl %ecx, %ecx
testb %bpl, %bpl
cmovneq %rax, %rcx
movq %rcx, 0x28(%rbx)
movq 0x8(%rbx), %rax
pushq $0xc
popq %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
je 0x9bff
orl $-0x1, (%rax,%rcx)
addq $0x18, %rcx
jmp 0x9bec
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x9c63
movq (%r14), %rdi
cmpl $0x0, 0xc(%rdi,%r15)
js 0x9c5a
cmpb $0x1, 0x8(%rdi,%r15)
jne 0x9c47
addq %r15, %rdi
callq 0x420d
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x9c5a
movq (%r14), %rcx
movq 0x10(%rcx,%r15), %rdi
callq *%rax
incq %r12
addq $0x18, %r15
jmp 0x9c23
movq %r14, %rdi
callq 0x420d
movl $0x300, %esi            # imm = 0x300
movq %r14, %rdi
callq 0x415c
testb %al, %al
jne 0x9c8a
leaq 0x239d(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x25ca
movq (%r14), %rax
pushq $0xc
popq %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
je 0x9ca3
orl $-0x1, (%rax,%rcx)
addq $0x18, %rcx
jmp 0x9c90
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
leaq 0x7bb8(%rip), %rax      # 0x11d50
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0xa1e5
movq (%rbx), %rdi
cmpl $0x0, 0xc(%rdi,%r15)
js 0xa1dc
cmpb $0x1, 0x8(%rdi,%r15)
jne 0xa1c9
addq %r15, %rdi
callq 0x420d
movq 0x28(%r14), %rax
testq %rax, %rax
je 0xa1dc
movq (%rbx), %rcx
movq 0x10(%rcx,%r15), %rdi
callq *%rax
incq %r12
addq $0x18, %r15
jmp 0xa1a5
movq %rbx, %rdi
callq 0x420d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa1fb
movq %rax, %rdi
callq 0x765e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x4(%rsp), %r15
orl $-0x1, (%r15)
movq %rax, %rsi
movq %r15, %rdx
callq 0xaf36
cmpl $0x1, (%r15)
jne 0xa3cc
movq 0x18(%r14), %rcx
imulq $0x18, %rax, %rdx
movl %ebx, 0x8(%rcx,%rdx)
jmp 0xa3cf
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x77fb(%rip), %rax      # 0x11d80
movq %rax, (%rdi)
leaq 0x1739(%rip), %rax      # 0xbcc8
xorl %ecx, %ecx
testl %edx, %edx
cmovneq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rcx, 0x18(%rdi)
testl %esi, %esi
jg 0xa66a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa682
cmpl %ebx, 0x10(%r14)
jle 0xa692
leaq 0x207c(%rip), %rdi      # 0xc705
movl %ebx, %esi
xorl %eax, %eax
callq 0x25ca
cmpl %ebx, 0x14(%r14)
je 0xa6f5
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0xa6df
movl %ebx, %eax
shlq $0x3, %rax
testl %ebx, %ebx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0xa6f1
movslq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0xa6d5
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x23c0
movq %r15, %rdi
callq 0x2320
jmp 0xa6f1
testq %r15, %r15
je 0xa6ec
movq %r15, %rdi
callq 0x2320
andq $0x0, 0x8(%r14)
movl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x10(%rdi)
je 0xaed9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %r14
movb (%rdi), %cl
pushq $0x1
popq %rax
shll %cl, %eax
xorl %esi, %esi
cmpq $0x0, 0x8(%rdi)
cmovnel %eax, %esi
imull $0x9e3779b9, 0xc(%rdx), %ebx # imm = 0x9E3779B9
negb %cl
shrl %cl, %ebx
movq %rsi, 0x8(%rsp)
leal -0x1(%rsi), %eax
movl %eax, 0x14(%rsp)
movl %ebx, %ebp
movq 0x8(%r14), %rax
movl %ebp, %r12d
shrl $0x5, %r12d
movl (%rax,%r12,4), %eax
pushq $0x1
popq %r15
movl %ebp, %ecx
shll %cl, %r15d
btl %ebp, %eax
jae 0xaed2
movl %ebp, %esi
shlq $0x4, %rsi
addq 0x10(%r14), %rsi
leaq 0x7(%rsp), %rdi
movq %rdx, %r13
callq 0xae22
testb %al, %al
jne 0xaedc
incl %ebp
andl 0x14(%rsp), %ebp
cmpl %ebx, %ebp
movq %r13, %rdx
jne 0xae8d
movq 0x8(%rsp), %rax
jmp 0xaeeb
xorl %eax, %eax
retq
movq 0x8(%r14), %rax
testl %r15d, (%rax,%r12,4)
cmovel 0x8(%rsp), %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gpertea[P]gclib/./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 0xbd26
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0xbd26
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq *0x18(%rbx)
incq %r14
jmp 0xbd0d
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0xbd38
callq 0x2320
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl $0x13d8, %edi           # imm = 0x13D8
callq 0x21c0
movq %rax, %rbx
testq %rax, %rax
je 0x2c59
movq $0xc8, 0x10(%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0xe0(%rbx)
leaq 0xf0(%rbx), %rax
movq %rax, 0x730(%rbx)
movq %rbx, %rax
addq $0x740, %rax            # imm = 0x740
movq %rax, 0x13c0(%rbx)
movq %rbx, %rdi
callq 0x2c63
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cd9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe0(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x2ccb
callq 0x2190
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2190
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0x5dc8(%rip), %eax      # 0xb290
movq 0x5dc9(%rip), %rcx      # 0xb298
movq 0x5dca(%rip), %rdx      # 0xb2a0
movq (%rcx,%rdx,8), %rcx
addl 0x28(%rcx), %eax
movq 0x5da4(%rip), %rdx      # 0xb288
leaq 0x4(%rdx), %rcx
movq %rcx, 0x5dc9(%rip)      # 0xb2b8
movl %eax, (%rdx)
movq 0x5d08(%rip), %rdx      # 0xb200
movq 0x5da9(%rip), %rsi      # 0xb2a8
leaq 0x23da(%rip), %rdi      # 0x78e0
leaq 0x2183(%rip), %r8       # 0x7690
leaq 0x26dc(%rip), %r9       # 0x7bf0
leaq 0x2535(%rip), %r10      # 0x7a50
leaq 0x269e(%rip), %r11      # 0x7bc0
leaq 0x2067(%rip), %rbx      # 0x7590
cmpq %rsi, %rdx
jae 0x5585
movzbl (%rdx), %r14d
testq %r14, %r14
je 0x553c
addq %rbx, %r14
jmp 0x5566
movb $0x1, %r14b
movzbl %r14b, %r14d
cltq
movswq (%rdi,%rax,2), %r15
addq %r14, %r15
movswl (%r8,%r15,2), %r12d
cmpl %r12d, %eax
je 0x556b
movswl (%r10,%rax,2), %eax
cmpl $0xac, %eax
jl 0x5543
addq %r11, %r14
movb (%r14), %r14b
jmp 0x553f
movswl (%r9,%r15,2), %eax
leaq 0x4(%rcx), %r14
movq %r14, 0x5d3d(%rip)      # 0xb2b8
movl %eax, (%rcx)
incq %rdx
movq %r14, %rcx
jmp 0x5529
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d9d(%rip), %rdi      # 0xb2d7
callq 0x32d0
movl (%rbx), %esi
leaq 0x7af8(%rip), %rdi      # 0xb040
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x3030
movl 0x4(%rbx), %esi
leaq 0x7af6(%rip), %rdi      # 0xb052
xorl %eax, %eax
callq 0x3030
movsd 0x8(%rbx), %xmm0
leaq 0x7aef(%rip), %rdi      # 0xb05e
movb $0x1, %al
callq 0x3030
movsd 0x10(%rbx), %xmm0
leaq 0x7aef(%rip), %rdi      # 0xb071
movb $0x1, %al
callq 0x3030
movsd 0x18(%rbx), %xmm0
leaq 0x7aef(%rip), %rdi      # 0xb084
movb $0x1, %al
callq 0x3030
movsd 0x20(%rbx), %xmm0
leaq 0x7aef(%rip), %rdi      # 0xb097
movb $0x1, %al
callq 0x3030
movsd 0x28(%rbx), %xmm0
leaq 0x7aef(%rip), %rdi      # 0xb0aa
movb $0x1, %al
callq 0x3030
movsd 0x30(%rbx), %xmm0
leaq 0x7afc(%rip), %rdi      # 0xb0ca
movb $0x1, %al
callq 0x3030
movsd 0x38(%rbx), %xmm0
leaq 0x7b09(%rip), %rdi      # 0xb0ea
movb $0x1, %al
callq 0x3030
pushq $0xa
popq %rdi
callq 0x3270
leaq 0x7cf3(%rip), %rdi      # 0xb2ea
callq 0x32d0
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x3622
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
callq 0x32d0
incq %r14
jmp 0x35fc
pushq $0xa
popq %rdi
callq 0x3270
leaq 0x7cd6(%rip), %rdi      # 0xb307
callq 0x32d0
xorl %r14d, %r14d
movq 0x58(%rbx), %rax
movq 0x60(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x365f
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
callq 0x32d0
incq %r14
jmp 0x3639
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x4fae
addq $0x78, %r15
cmpq %r15, %rax
je 0x42d8
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x4792
movslq %ebp, %rcx
movq (%rax), %rax
imulq $0x18, %rcx, %rcx
movslq %ebx, %rdx
movq (%rax,%rcx), %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 %r14
popq %r15
popq %rbp
retq
leaq 0x6ef6(%rip), %rdi      # 0xb1d5
leaq 0x6f10(%rip), %rsi      # 0xb1f6
leaq 0x6f26(%rip), %rcx      # 0xb213
pushq $0x67
popq %rdx
callq 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/calculate-routing-metrics.cc
// Function: RoutingMetrics::GetData(double, int, int) const
double GetData(double range, int builder, int calculator) const {
    const std::pair<double, int>& p = data_[range][builder][calculator];
    if (p.second > 0) {
      return p.first / p.second;
    } else {
      return 0.0;
    }
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rsp, %rsi
movsd %xmm0, (%rsi)
addq $0x70, %rdi
callq 0x4792
movslq %ebp, %rcx
movq (%rax), %rdx
imulq $0x18, %rcx, %rcx
movslq %ebx, %rax
movq (%rdx,%rcx), %rcx
shlq $0x4, %rax
movl 0x8(%rcx,%rax), %edx
testl %edx, %edx
jg 0x4330
xorpd %xmm0, %xmm0
jmp 0x433d
movsd (%rcx,%rax), %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x48
popq %r12
cqto
idivq %r12
movslq %eax, %rsi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x9f26
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x93f1
movl %ecx, (%rdi,%rcx,8)
movl $0x1, 0x4(%rdi,%rcx,8)
incq %rcx
jmp 0x93dc
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %r12
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movl %edx, %r8d
cmpl %eax, %edx
jne 0x9415
jmp 0x942a
incl 0x4(%rdi,%r8,8)
movl %r8d, %r8d
imulq $0x48, %r8, %r8
movslq 0x44(%rcx,%r8), %r8
testq %r8, %r8
jns 0x9410
incl %edx
jmp 0x9407
callq 0xa1b1
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x9f78
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x946b
movl (%rax,%rdx,8), %esi
movq (%rbx), %rdi
movl %esi, (%rdi,%rdx,4)
incq %rdx
jmp 0x9458
leaq 0x10(%rsp), %rdi
callq 0xa0d8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa0d8
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/routing-metric-calculators.cc
// Function: DataAggregationCalculator::CalculateMetric(SensorNetwork const&)
double DataAggregationCalculator::CalculateMetric(const SensorNetwork& network) {
  // TODO: Make it an argument.
  static const double sensing_range = 15.0;
  std::vector<int> triggered;
  Position position(50.0, 50.0);  // FIXME: pass in region to the calculator.
  if (!network.FindSensorsWithinRange(position, sensing_range, &triggered)) {
    // No sensor will ever be triggered by the event.
    return 0.0;
  }

  std::set<int> visited;
  visited.insert(0);

  int num_transmissions = 1;
  for (int i = 0; i < triggered.size(); i++) {
    visited.insert(triggered[i]);
    num_transmissions++;
    int parent = network.GetParent(triggered[i]);
    while (visited.find(parent) == visited.end()) {
      visited.insert(parent);
      num_transmissions++;
      parent = network.GetParent(parent);
      assert(parent >= 0);
    }
  }

  return num_transmissions;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
andq $0x0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movaps 0x287c(%rip), %xmm0     # 0xc1b0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movsd 0x287c(%rip), %xmm0     # 0xc1c0
movq %rbx, %rdi
callq 0x5c6e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testb %al, %al
je 0x9a2c
leaq 0x38(%rsp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x79bc
pushq $0x1
popq %rbp
xorl %r13d, %r13d
leaq 0x30(%rsp), %r14
leaq 0x4(%rsp), %r15
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x9a18
leaq (%rax,%r13,4), %rsi
movq %r14, %rdi
callq 0x6b7e
movq 0x10(%rsp), %rax
movslq (%rax,%r13,4), %rax
movq (%rbx), %rcx
imulq $0x48, %rax, %rax
movl 0x44(%rcx,%rax), %eax
movl %eax, 0x4(%rsp)
incl %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0xa704
cmpq %r12, %rax
jne 0x9a13
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b7e
movslq 0x4(%rsp), %rax
movq (%rbx), %rcx
imulq $0x48, %rax, %rax
movl 0x44(%rcx,%rax), %eax
movl %eax, 0x4(%rsp)
incl %ebp
testl %eax, %eax
jns 0x99dc
jmp 0x9a4b
incq %r13
jmp 0x99a0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4724
leaq 0x10(%rsp), %rdi
callq 0x7156
movsd 0x8(%rsp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x283c(%rip), %rdi      # 0xc28e
leaq 0x27a1(%rip), %rsi      # 0xc1fa
leaq 0x2886(%rip), %rcx      # 0xc2e6
movl $0xbe, %edx
callq 0x3110
jmp 0x9a75
movq %rax, %rbx
jmp 0x9a82
jmp 0x9a75
jmp 0x9a75
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4724
leaq 0x10(%rsp), %rdi
callq 0x7156
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::OptimalSolverLN()
OptimalSolverLN::OptimalSolverLN() {
	matrix = NULL;
	base = NULL;
	defaultMatrix = NULL;
	defaultBase = NULL;
	readLength = 0;
	seedNum = 0;
	matrixSize = 0;
	baseSize = 0;
	L0Loaded = false;
	minLength = 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
pushq $0xa
popq %rsi
pushq $0x1e
popq %rdx
callq 0x7164
xorps %xmm0, %xmm0
movups %xmm0, 0x3e8(%rbx)
andq $0x0, 0x3f8(%rbx)
andq $0x0, 0x360(%rbx)
movb $0x0, (%rbx)
movups %xmm0, 0x370(%rbx)
movups %xmm0, 0x380(%rbx)
movups %xmm0, 0x390(%rbx)
movups %xmm0, 0x3a0(%rbx)
movups %xmm0, 0x3b0(%rbx)
movups %xmm0, 0x3c0(%rbx)
movups %xmm0, 0x3d0(%rbx)
movl $0x1, 0x368(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x370(%rdi), %rdi
testq %rdi, %rdi
je 0x4256
callq 0x3300
andq $0x0, 0x370(%rbx)
movq 0x378(%rbx), %rdi
testq %rdi, %rdi
je 0x426f
callq 0x3300
andq $0x0, 0x378(%rbx)
movq 0x3b0(%rbx), %rdi
testq %rdi, %rdi
je 0x4288
callq 0x3300
andq $0x0, 0x3b0(%rbx)
movq 0x3b8(%rbx), %rdi
testq %rdi, %rdi
je 0x42a1
callq 0x3300
andq $0x0, 0x3b8(%rbx)
movq 0x380(%rbx), %rax
cmpq %rax, 0x388(%rbx)
je 0x42b8
movq %rax, 0x388(%rbx)
movq 0x398(%rbx), %rax
cmpq %rax, 0x3a0(%rbx)
je 0x42cf
movq %rax, 0x3a0(%rbx)
leaq 0x380(%rbx), %r14
leaq 0x398(%rbx), %r15
leaq 0x3c8(%rbx), %r12
movq 0x3c8(%rbx), %rax
cmpq %rax, 0x3d0(%rbx)
je 0x42fb
movq %rax, 0x3d0(%rbx)
leaq 0x3e8(%rbx), %rdi
callq 0x59ec
movq %r12, %rdi
callq 0x59b0
movq %r15, %rdi
callq 0x597c
movq %r14, %rdi
callq 0x597c
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x72a8
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x4746
movl $0xa, 0x8(%rbx)
movl 0x360(%rbx), %eax
subl 0x368(%rbx), %eax
incl %eax
cltq
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %ecx
movq %rax, 0x8(%rsp)
cmovgl %eax, %ecx
movq %rcx, 0x10(%rsp)
movq 0xc80d(%rip), %r14      # 0x10fd8
cmpq 0x10(%rsp), %r12
je 0x4861
movq 0x8(%rsp), %rbp
subq %r12, %rbp
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %rbp, %r13
jge 0x4859
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x3460
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%r15), %rsi
addq $0x4, %rsi
movq %r14, %rdi
callq 0x3460
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%r15), %rsi
addq $0xc, %rsi
movq %r14, %rdi
callq 0x3460
movq 0x398(%rbx), %rax
movq (%rax,%r12,8), %rax
leaq (%rax,%r15), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x31f0
incq %r13
addq $0x28, %r15
jmp 0x47e4
incq %r12
jmp 0x47cb
movb $0x1, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::calculateLastDiv()
unsigned int OptimalSolverLN::calculateLastDiv() {
	// The last level

	if (seedNum > 1) {
		int lvPosCount = readLength - seedNum * minLength;
		finalDiv = solveFirstOptimal(lvPosCount, lvPosCount, seedNum - 1);
	}
	else {
		finalDiv = readLength;
	}

#ifdef DEBUG
	cout << "opt_div: " << finalDiv << endl;
#endif

	return finalDiv;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x360(%rdi), %eax
movl 0x364(%rdi), %ecx
cmpl $0x2, %ecx
jl 0x544a
movl 0x368(%rbx), %edx
imull %ecx, %edx
subl %edx, %eax
decl %ecx
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x511a
movl %eax, 0x3e0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::calcualteFreq()
unsigned int OptimalSolverLN::calcualteFreq() {
	int bestFreq;

	if (seedNum > 1) {
		int lvPosCount = readLength - seedNum * minLength;
		bestFreq = level[seedNum - 2][finalDiv].frequency + level0[lvPosCount - finalDiv][finalDiv + (seedNum - 1) * minLength].frequency;
	} else
		bestFreq = level0[readLength - minLength][0].frequency;
	
#ifdef DEBUG
	cout << "bestFreq: " << bestFreq << endl;
#endif

	return bestFreq;
}

// Assembly:
movslq 0x364(%rdi), %rax
cmpq $0x2, %rax
jl 0x54a9
movl 0x360(%rdi), %ecx
movl 0x368(%rdi), %edx
leal -0x1(%rax), %esi
imull %edx, %esi
imull %eax, %edx
movq 0x380(%rdi), %r8
movq -0x10(%r8,%rax,8), %r8
movl 0x3e0(%rdi), %eax
imulq $0x28, %rax, %r9
addl %eax, %edx
subl %edx, %ecx
movq 0x398(%rdi), %rdx
movq (%rdx,%rcx,8), %rcx
addl %eax, %esi
imulq $0x28, %rsi, %rax
movl 0xc(%rcx,%rax), %eax
addl 0xc(%r8,%r9), %eax
retq
movslq 0x360(%rdi), %rax
movslq 0x368(%rdi), %rcx
subq %rcx, %rax
movq 0x398(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movl 0xc(%rax), %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
unsigned int OptimalSolverLN::solveDNA(string& DNA) {
	fillMatrix(DNA);
	calculateLastDiv();
	processedReads++;
	return calcualteFreq();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4c92
movq %rbx, %rdi
callq 0x541c
incl 0x400(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x5452
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::backtrack()
void OptimalSolverLN::backtrack() {
	if (seedNum > 1) {
		int seedIdx = seedNum - 1;
		int level0lv = readLength - seedNum * minLength - finalDiv;
		int level0pos = finalDiv + (seedNum - 1) * minLength;
		seeds[seedIdx].start = level0[level0lv][level0pos].start;
		seeds[seedIdx].end = level0[level0lv][level0pos].end;
		seeds[seedIdx].frequency = level0[level0lv][level0pos].frequency;
	
		int opt_div = finalDiv;
	
		for (seedIdx = seedNum - 2; seedIdx >= 0; seedIdx--) {
			seeds[seedIdx].start = level[seedIdx][opt_div].rstart;
			seeds[seedIdx].end = level[seedIdx][opt_div].rend;
			seeds[seedIdx].frequency = level[seedIdx][opt_div].rfreq;
			opt_div = level[seedIdx][opt_div].lend + 1 - seedIdx * minLength;
		}
	}
	else {
		seeds[0].start = level0[readLength - minLength][0].start;
		seeds[0].end = level0[readLength - minLength][0].end;
		seeds[0].frequency = level0[readLength - minLength][0].frequency;
	}
}

// Assembly:
movl 0x360(%rdi), %esi
movl 0x364(%rdi), %ecx
movl 0x368(%rdi), %eax
cmpl $0x2, %ecx
jl 0x55a8
leal -0x1(%rcx), %r8d
movl %eax, %r9d
imull %ecx, %r9d
movl 0x3e0(%rdi), %edx
addl %edx, %r9d
subl %r9d, %esi
movl %eax, %r9d
imull %r8d, %r9d
addl %edx, %r9d
movslq %esi, %r10
movq 0x398(%rdi), %r11
movq 0x3c8(%rdi), %rsi
movq (%r11,%r10,8), %r10
movslq %r9d, %r9
imulq $0x28, %r9, %r9
imulq $0x28, %r8, %r8
movq (%r10,%r9), %r11
movq %r11, (%rsi,%r8)
movl 0xc(%r10,%r9), %r9d
movl %r9d, 0xc(%rsi,%r8)
addl $-0x2, %ecx
movq 0x380(%rdi), %rdi
movl %eax, %r9d
imull %ecx, %r9d
pushq $0x1
popq %r8
subl %r9d, %r8d
testl %ecx, %ecx
js 0x55cb
movl %ecx, %r9d
movq (%rdi,%r9,8), %r10
movslq %edx, %rdx
imulq $0x28, %rdx, %rdx
imulq $0x28, %r9, %r9
movq 0x1c(%r10,%rdx), %r11
movq %r11, (%rsi,%r9)
movl 0x24(%r10,%rdx), %r11d
movl %r11d, 0xc(%rsi,%r9)
movl 0x14(%r10,%rdx), %edx
addl %r8d, %edx
decl %ecx
addl %eax, %r8d
jmp 0x5570
subl %eax, %esi
movslq %esi, %rax
movq 0x398(%rdi), %rcx
movq 0x3c8(%rdi), %rdx
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
movq %rcx, (%rdx)
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printSeeds(std::ostream&)
void OptimalSolverLN::printSeeds(ostream& stream) {
	for (int i = 0; i < seedNum; i++) {
		stream << "Seed[" << i << "]: start: " << seeds[i].start;
		stream << " end: " << seeds[i].end;
		stream << " frequency: " << seeds[i].frequency;
		stream << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x5cd7(%rip), %r13      # 0xb2fc
leaq 0x5eff(%rip), %rbp      # 0xb52b
xorl %r15d, %r15d
movslq 0x364(%r14), %rax
cmpq %rax, %r15
jge 0x56cd
movq %rbx, %rdi
leaq 0x5ca2(%rip), %rsi      # 0xb2eb
callq 0x3240
movq %rax, %rdi
movl %r15d, %esi
callq 0x3440
movq %rax, %rdi
leaq 0x5c8e(%rip), %rsi      # 0xb2f1
callq 0x3240
movq 0x3c8(%r14), %rcx
movl (%rcx,%r12), %esi
movq %rax, %rdi
callq 0x3190
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3240
movq 0x3c8(%r14), %rcx
movl 0x4(%rcx,%r12), %esi
movq %rax, %rdi
callq 0x3190
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3240
movq 0x3c8(%r14), %rcx
movl 0xc(%rcx,%r12), %esi
movq %rax, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3120
incq %r15
addq $0x28, %r12
jmp 0x562f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq