LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8dfe
movq 0x20(%rdi), %rdx
leaq (%rcx,%rcx,2), %rsi
leaq (%rdx,%rsi,8), %rdx
addq $0x8, %rdx
movq %rcx, %r8
subq %rax, %r8
xorl %eax, %eax
xorl %esi, %esi
cmpq $0x0, -0x8(%rdx)
je 0x8e01
addq $0x18, %rdx
decq %rsi
cmpq %rsi, %r8
jne 0x8dea
retq
xorl %eax, %eax
retq
subl %esi, %ecx
incl %ecx
movl %ecx, 0x30(%rdi)
movq (%rdx), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e4f
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 0x8e52
decq %r8
addq $0x18, %rdx
cmpq %r8, %rsi
jne 0x8e3b
xorl %eax, %eax
retq
subl %r8d, %ecx
incl %ecx
movl %ecx, 0x34(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
movl 0x28(%rdi), %ecx
xorl %eax, %eax
cmpl %ecx, %esi
jge 0x8e9c
movq 0x20(%rdi), %rdx
leaq (%rsi,%rsi,2), %r8
leaq (%rdx,%r8,8), %rdx
addq $0x10, %rdx
incl %esi
negl %ecx
cmpq $0x0, -0x10(%rdx)
je 0x8e89
cmpl $0x0, (%rdx)
jns 0x8e9d
addq $0x18, %rdx
leal (%rcx,%rsi), %r8d
incl %r8d
incl %esi
cmpl $0x1, %r8d
jne 0x8e7d
retq
movl %esi, 0x34(%rdi)
movq 0x8(%rdi), %rax
movslq (%rdx), %rcx
shlq $0x4, %rcx
movl 0xc(%rax,%rcx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ee2
movq %rax, %xmm1
punpckldq 0x528f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x8(%rbx)
subpd 0x5293(%rip), %xmm1     # 0xe290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x528f(%rip), %xmm0     # 0xe2a0
leaq 0x52d0(%rip), %rdi      # 0xe2e8
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 0x524d(%rip), %xmm1     # 0xe2a8
mulsd 0x524d(%rip), %xmm0     # 0xe2b0
addsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9085
leaq 0x527d(%rip), %rdi      # 0xe2fb
xorl %eax, %eax
callq 0x289c
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 0x51e6(%rip), %xmm0     # 0xe2a8
mulsd 0x51e6(%rip), %xmm1     # 0xe2b0
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x8ee2
movq %rax, %xmm1
punpckldq 0x519a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rbx)
subpd 0x519e(%rip), %xmm1     # 0xe290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x519a(%rip), %xmm0     # 0xe2a0
leaq 0x522b(%rip), %rdi      # 0xe338
movb $0x1, %al
callq 0x2470
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9149
cmpb $0x0, 0x1(%rbx)
jne 0x915e
leaq 0x51fa(%rip), %rdi      # 0xe34a
leaq 0x5238(%rip), %rsi      # 0xe38f
xorl %eax, %eax
callq 0x289c
cvtsi2sdq 0x138(%rbx), %xmm1
cvtsi2sdq 0x140(%rbx), %xmm2
movsd 0x5130(%rip), %xmm3     # 0xe2a8
divsd %xmm3, %xmm2
movsd 0x512c(%rip), %xmm4     # 0xe2b0
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_O1/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 0x91c3
cmpb $0x0, 0x1(%rbx)
jne 0x91d8
leaq 0x5180(%rip), %rdi      # 0xe34a
leaq 0x51b2(%rip), %rsi      # 0xe383
xorl %eax, %eax
callq 0x289c
cvtsi2sdq 0x18(%rbx), %xmm1
cvtsi2sdq 0x20(%rbx), %xmm0
movsd 0x50c4(%rip), %xmm2     # 0xe2b0
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_O1/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 0x9227
cmpb $0x0, 0x1(%rbx)
jne 0x923c
leaq 0x511c(%rip), %rdi      # 0xe34a
leaq 0x5158(%rip), %rsi      # 0xe38d
xorl %eax, %eax
callq 0x289c
cvtsi2sdq 0x28(%rbx), %xmm1
cvtsi2sdq 0x30(%rbx), %xmm0
movsd 0x5060(%rip), %xmm2     # 0xe2b0
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_O1/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 0x913a
cvttsd2si %xmm0, %rax
subsd 0x4da2(%rip), %xmm0     # 0xe3a8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x450c
movq %rax, %rbx
movq %r12, %rdi
callq 0x91b4
cvttsd2si %xmm0, %rax
subsd 0x4d73(%rip), %xmm0     # 0xe3a8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x450c
movq %rax, %r14
movq %r12, %rdi
callq 0x9218
cvttsd2si %xmm0, %rax
subsd 0x4d44(%rip), %xmm0     # 0xe3a8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x450c
movq %rax, %r15
movq %r12, %rdi
callq 0x927c
cvttsd2si %xmm0, %rax
subsd 0x4d15(%rip), %xmm0     # 0xe3a8
cvttsd2si %xmm0, %rcx
movq %rax, %rdi
sarq $0x3f, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x450c
movq %rax, %r12
leaq 0x4d15(%rip), %rdi      # 0xe3c9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x4d2a(%rip), %rdi      # 0xe3ef
movq %r14, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x4d3f(%rip), %rdi      # 0xe415
movq %r15, %rsi
xorl %eax, %eax
callq 0x2470
leaq 0x4d54(%rip), %rdi      # 0xe43b
movq %r12, %rsi
xorl %eax, %eax
callq 0x2470
testq %rbx, %rbx
je 0x96fe
movq %rbx, %rdi
callq 0x22e0
testq %r14, %r14
je 0x970b
movq %r14, %rdi
callq 0x22e0
testq %r15, %r15
je 0x9718
movq %r15, %rdi
callq 0x22e0
testq %r12, %r12
je 0x9725
movq %r12, %rdi
callq 0x22e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaf31
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x10(%rdi), %r15
movl 0x14(%rdi), %eax
cmpl %eax, %r15d
jne 0xaf1a
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x9, %eax
movl $0x1, %esi
cmovgel %ecx, %esi
addl %eax, %esi
movq %rbx, %rdi
callq 0xbb0c
movq 0x8(%rbx), %rax
movq %r14, (%rax,%r15,8)
movl 0x10(%rbx), %eax
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_O1/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 0x8dcd(%rip), %rax      # 0x13d50
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x300, %edi            # imm = 0x300
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xafaf
leaq 0x3078(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
leaq 0xb25(%rip), %rcx       # 0xbae4
testb %bpl, %bpl
cmoveq %rax, %rcx
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x8(%rbx), %rax
movl $0xc, %ecx
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
addq $0x18, %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
jne 0xafd7
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/./GHash.hh
// Function: old::GHash<int>::Clear()
void GHash<OBJ>::Clear(){
	int i;
	for(i=0; i<fCapacity; i++){
		if(hash[i].hash>=0){
			if (hash[i].keyalloc) GFREE((hash[i].key));
			if (FREEDATA)
				(*fFreeProc)(hash[i].data);
		}
	}
	GFREE(hash);
	GMALLOC(hash, sizeof(GHashEntry)*DEF_HASH_SIZE);
	//reinitialize it
	for (i=0; i<DEF_HASH_SIZE; i++)
		hash[i].hash=-1; //this will be an indicator for 'empty' entries
	fCapacity=DEF_HASH_SIZE;
	fCount=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0xb087
xorl %r12d, %r12d
leaq 0x3254(%rip), %r14      # 0xe26c
leaq 0x3251(%rip), %r15      # 0xe270
xorl %r13d, %r13d
movq 0x8(%rbx), %rbp
cmpl $0x0, 0xc(%rbp,%r12)
js 0xb077
cmpb $0x1, 0x8(%rbp,%r12)
jne 0xb063
testq %rbp, %rbp
jne 0xb04b
movq %r14, %rdi
movq %r15, %rsi
movl $0xf6, %edx
callq 0x285c
movq (%rbp,%r12), %rdi
testq %rdi, %rdi
je 0xb05a
callq 0x22e0
movq $0x0, (%rbp,%r12)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xb077
movq 0x8(%rbx), %rcx
movq 0x10(%rcx,%r12), %rdi
callq *%rax
incq %r13
movslq 0x10(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0xb022
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb095
callq 0x22e0
movq $0x0, 0x8(%rbx)
movl $0x300, %edi            # imm = 0x300
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xb0be
leaq 0x2f69(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
movq 0x8(%rbx), %rax
movl $0xc, %ecx
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
addq $0x18, %rcx
cmpq $0x30c, %rcx            # imm = 0x30C
jne 0xb0c7
movq $0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/./GHash.hh
// Function: old::GHash<int>::~GHash()
GHash<OBJ>::~GHash(){
	for(int i=0; i<fCapacity; i++){
		if(hash[i].hash>=0){
			if (hash[i].keyalloc) GFREE((hash[i].key));
			if (FREEDATA) (*fFreeProc)(hash[i].data);
		}
	}
	GFREE(hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8787(%rip), %rax      # 0x13d50
movq %rax, (%rdi)
cmpl $0x0, 0x10(%rdi)
jle 0xb64b
xorl %r12d, %r12d
leaq 0x2c90(%rip), %r14      # 0xe26c
leaq 0x2c8d(%rip), %r15      # 0xe270
xorl %r13d, %r13d
movq 0x8(%rbx), %rbp
cmpl $0x0, 0xc(%rbp,%r12)
js 0xb63b
cmpb $0x1, 0x8(%rbp,%r12)
jne 0xb627
testq %rbp, %rbp
jne 0xb60f
movq %r14, %rdi
movq %r15, %rsi
movl $0xf6, %edx
callq 0x285c
movq (%rbp,%r12), %rdi
testq %rdi, %rdi
je 0xb61e
callq 0x22e0
movq $0x0, (%rbp,%r12)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xb63b
movq 0x8(%rbx), %rcx
movq 0x10(%rcx,%r12), %rdi
callq *%rax
incq %r13
movslq 0x10(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0xb5e6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb659
callq 0x22e0
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x8eb0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb24
cmpl %ebx, 0x10(%r14)
jle 0xbb34
leaq 0x2b5a(%rip), %rdi      # 0xe685
movl %ebx, %esi
xorl %eax, %eax
callq 0x289c
cmpl %ebx, 0x14(%r14)
je 0xbb9f
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0xbb86
movslq %ebx, %rax
shlq $0x3, %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0xbb9b
movslq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0xbb7c
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x23c0
movq %r15, %rdi
callq 0x2320
jmp 0xbb9b
testq %r15, %r15
je 0xbb93
movq %r15, %rdi
callq 0x2320
movq $0x0, 0x8(%r14)
movl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc3a0
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 0xc399
movl %r13d, %eax
shlq $0x4, %rax
cmpl %ebp, 0xc(%r15,%rax)
jne 0xc38e
addq %r15, %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2350
testl %eax, %eax
je 0xc3a4
incl %r13d
andl %ebx, %r13d
cmpl %r14d, %r13d
jne 0xc35c
movq 0x8(%rsp), %rax
jmp 0xc3a7
xorl %eax, %eax
jmp 0xc3a7
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_O1/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 0xd156
cmpl $0x0, 0x10(%rbx)
jle 0xd156
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 0xd13f
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0xd168
callq 0x2320
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3028
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)
jmp 0x302a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x305d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe0(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x304f
callq 0x21b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51d7(%rip), %eax      # 0xb290
movq 0x51d8(%rip), %rcx      # 0xb298
movq 0x51d9(%rip), %rdx      # 0xb2a0
movq (%rcx,%rdx,8), %rcx
addl 0x28(%rcx), %eax
movq 0x51b3(%rip), %rdx      # 0xb288
leaq 0x4(%rdx), %rcx
movq %rcx, 0x51d8(%rip)      # 0xb2b8
movl %eax, (%rdx)
movq 0x5117(%rip), %rdx      # 0xb200
movq 0x51b8(%rip), %rsi      # 0xb2a8
cmpq %rsi, %rdx
jae 0x61a2
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x1803(%rip), %rdi      # 0x7910
leaq 0x15ac(%rip), %r8       # 0x76c0
leaq 0x1b05(%rip), %r9       # 0x7c20
leaq 0x195e(%rip), %r10      # 0x7a80
leaq 0x1ac7(%rip), %r11      # 0x7bf0
leaq 0x1490(%rip), %rbx      # 0x75c0
movzbl (%rdx), %r14d
testq %r14, %r14
je 0x613f
movb (%r14,%rbx), %r14b
jmp 0x6142
movb $0x1, %r14b
cltq
movswq (%rdi,%rax,2), %r12
movzbl %r14b, %r15d
addq %r15, %r12
movswl (%r8,%r12,2), %r13d
cmpl %r13d, %eax
je 0x617e
movswq (%r10,%rax,2), %rax
cmpq $0xac, %rax
jl 0x616b
movb (%r15,%r11), %r14b
movswq (%rdi,%rax,2), %r12
movzbl %r14b, %r15d
addq %r15, %r12
cmpw (%r8,%r12,2), %ax
jne 0x615a
movswl (%r9,%r12,2), %eax
movl %eax, (%rcx)
addq $0x4, %rcx
incq %rdx
cmpq %rsi, %rdx
jne 0x6130
movq %rcx, 0x5120(%rip)      # 0xb2b8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b7d(%rip), %rdi      # 0xc2b7
callq 0x32d0
movl (%rbx), %esi
leaq 0x88d8(%rip), %rdi      # 0xc020
xorl %eax, %eax
callq 0x3040
movl 0x4(%rbx), %esi
leaq 0x88d9(%rip), %rdi      # 0xc032
xorl %eax, %eax
callq 0x3040
movsd 0x8(%rbx), %xmm0
leaq 0x88d2(%rip), %rdi      # 0xc03e
movb $0x1, %al
callq 0x3040
movsd 0x10(%rbx), %xmm0
leaq 0x88d2(%rip), %rdi      # 0xc051
movb $0x1, %al
callq 0x3040
movsd 0x18(%rbx), %xmm0
leaq 0x88d2(%rip), %rdi      # 0xc064
movb $0x1, %al
callq 0x3040
movsd 0x20(%rbx), %xmm0
leaq 0x88d2(%rip), %rdi      # 0xc077
movb $0x1, %al
callq 0x3040
movsd 0x28(%rbx), %xmm0
leaq 0x88d2(%rip), %rdi      # 0xc08a
movb $0x1, %al
callq 0x3040
movsd 0x30(%rbx), %xmm0
leaq 0x88df(%rip), %rdi      # 0xc0aa
movb $0x1, %al
callq 0x3040
movsd 0x38(%rbx), %xmm0
leaq 0x88ec(%rip), %rdi      # 0xc0ca
movb $0x1, %al
callq 0x3040
movl $0xa, %edi
callq 0x3280
leaq 0x8ad4(%rip), %rdi      # 0xc2ca
callq 0x32d0
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x382c
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 0x3808
movl $0xa, %edi
callq 0x3280
leaq 0x8aaa(%rip), %rdi      # 0xc2e7
callq 0x32d0
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0x3873
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 0x384f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl %edx, %ebx
movl %esi, %ebp
movsd %xmm0, 0x10(%rsp)
movq 0x80(%rdi), %rdx
leaq 0x78(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x4af3
movq %rax, %rcx
xorl %esi, %esi
ucomisd 0x20(%rdx), %xmm0
cmovbeq %rdx, %rcx
seta %sil
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x4ada
movq %rax, %rdx
cmpq %rax, %rcx
je 0x4b0c
movsd 0x20(%rcx), %xmm1
ucomisd %xmm0, %xmm1
movq %rax, %rdx
ja 0x4b0c
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x4b4f
addq $0x70, %rdi
leaq 0x10(%rsp), %rsi
callq 0x50d6
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 0x765f(%rip), %rdi      # 0xc1b5
leaq 0x7679(%rip), %rsi      # 0xc1d6
leaq 0x768f(%rip), %rcx      # 0xc1f3
movl $0x67, %edx
callq 0x3100
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb05a
movq (%r14), %r15
movq 0x8(%r14), %r14
movq %r14, %rax
subq %r15, %rax
sarq $0x3, %rax
cmpq %r15, %r14
je 0xa0d1
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 0xa0bc
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 0xa11c
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
leaq (%rsi,%rsi,8), %rdi
movl 0x44(%rcx,%rdi,8), %edi
testl %edi, %edi
js 0xa114
movl %edi, %edi
incl 0x4(%r15,%rdi,8)
leaq (%rdi,%rdi,8), %rdi
jmp 0xa0ff
incq %rsi
cmpq %rdx, %rsi
jne 0xa0fb
cmpq %r14, %r15
je 0xa144
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb23d
movq %r15, %rdi
movq %r14, %rsi
callq 0xb33b
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0xb0ec
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
je 0xa188
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 0xa17a
testq %rdi, %rdi
je 0xa19a
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 0xa1c0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x31e0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xa, %esi
movl $0x1e, %edx
callq 0x7bc4
xorl %eax, %eax
movq %rax, 0x3f8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x3e8(%rbx)
movq %rax, 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_O1/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 0x45fa
callq 0x3340
movq $0x0, 0x370(%rbx)
movq 0x378(%rbx), %rdi
testq %rdi, %rdi
je 0x4616
callq 0x3340
movq $0x0, 0x378(%rbx)
movq 0x3b0(%rbx), %rdi
testq %rdi, %rdi
je 0x4632
callq 0x3340
movq $0x0, 0x3b0(%rbx)
movq 0x3b8(%rbx), %rdi
testq %rdi, %rdi
je 0x464e
callq 0x3340
movq $0x0, 0x3b8(%rbx)
movq 0x380(%rbx), %rax
cmpq %rax, 0x388(%rbx)
je 0x4665
movq %rax, 0x388(%rbx)
movq 0x398(%rbx), %rax
cmpq %rax, 0x3a0(%rbx)
je 0x467c
movq %rax, 0x3a0(%rbx)
movq 0x3c8(%rbx), %rax
cmpq %rax, 0x3d0(%rbx)
je 0x4693
movq %rax, 0x3d0(%rbx)
movq 0x3e8(%rbx), %rdi
testq %rdi, %rdi
je 0x46ae
movq 0x3f8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
movq 0x3c8(%rbx), %rdi
testq %rdi, %rdi
je 0x46c9
movq 0x3d8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
movq 0x398(%rbx), %rdi
testq %rdi, %rdi
je 0x46e4
movq 0x3a8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
movq 0x380(%rbx), %rdi
testq %rdi, %rdi
je 0x46ff
movq 0x390(%rbx), %rsi
subq %rdi, %rsi
callq 0x3290
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7d0c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4cfb
movl %eax, %r13d
xorl %r12d, %r12d
movq 0xc36e(%rip), %r14      # 0x10fd8
movq %r13, (%rsp)
subq %r12, %r13
jle 0x4ceb
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 0x4c78
incq %r12
movq (%rsp), %r13
cmpq %r13, %r12
jne 0x4c6e
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ba2
movl 0x368(%rbx), %edx
imull %ecx, %edx
subl %edx, %eax
decl %ecx
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x5748
movl %eax, 0x3e0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c01
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
leaq (%rax,%rax,4), %r9
addl %eax, %edx
subl %edx, %ecx
movq 0x398(%rdi), %rdx
movq (%rdx,%rcx,8), %rcx
addl %eax, %esi
leaq (%rsi,%rsi,4), %rax
movl 0xc(%rcx,%rax,8), %eax
addl 0xc(%r8,%r9,8), %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_O1/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 0x51da
movq %rbx, %rdi
callq 0x5b74
incl 0x400(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x5baa
// File: /workspace/github_cpp_makefile_star2_O1/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), %edx
movl 0x368(%rdi), %eax
cmpl $0x2, %edx
jl 0x5d04
leal -0x1(%rdx), %r8d
movl %eax, %r9d
imull %edx, %r9d
movl 0x3e0(%rdi), %ecx
addl %ecx, %r9d
subl %r9d, %esi
movl %eax, %r9d
imull %r8d, %r9d
addl %ecx, %r9d
movslq %esi, %rsi
movq 0x398(%rdi), %r10
movq 0x3c8(%rdi), %r11
movq (%r10,%rsi,8), %rsi
movslq %r9d, %r9
leaq (%r9,%r9,4), %r9
leaq (%r8,%r8,4), %r8
movq (%rsi,%r9,8), %r10
movq %r10, (%r11,%r8,8)
movl 0xc(%rsi,%r9,8), %esi
movl %esi, 0xc(%r11,%r8,8)
addl $-0x2, %edx
movq 0x380(%rdi), %rsi
movl %edx, %r8d
imull %eax, %r8d
movl $0x1, %edi
subl %r8d, %edi
leaq (%rdx,%rdx,4), %r8
incq %rdx
leaq (%r11,%r8,8), %r8
movq -0x8(%rsi,%rdx,8), %r9
movslq %ecx, %rcx
leaq (%rcx,%rcx,4), %rcx
movq 0x1c(%r9,%rcx,8), %r10
movq %r10, (%r8)
movl 0x24(%r9,%rcx,8), %r10d
movl %r10d, 0xc(%r8)
movl 0x14(%r9,%rcx,8), %ecx
addl %edi, %ecx
addl %eax, %edi
addq $-0x28, %r8
decq %rdx
jg 0x5cd4
retq
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_O1/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:
cmpl $0x0, 0x364(%rdi)
jle 0x5e72
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x67d5(%rip), %rbp      # 0xc563
xorl %r15d, %r15d
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x656b(%rip), %rsi      # 0xc30b
callq 0x32e0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3450
movq %rax, %r12
movl $0xa, %edx
movq %rax, %rdi
leaq 0x654f(%rip), %rsi      # 0xc311
callq 0x32e0
movq 0x3c8(%r14), %rax
movl (%rax,%r13), %esi
movq %r12, %rdi
callq 0x31b0
movl $0x6, %edx
movq %rbx, %rdi
leaq 0x6533(%rip), %rsi      # 0xc31c
callq 0x32e0
movq 0x3c8(%r14), %rax
movl 0x4(%rax,%r13), %esi
movq %rbx, %rdi
callq 0x31b0
movl $0xc, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x32e0
movq 0x3c8(%r14), %rax
movl 0xc(%rax,%r13), %esi
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
incq %r15
movslq 0x364(%r14), %rax
addq $0x28, %r13
cmpq %rax, %r15
jl 0x5d91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printStats(std::ostream&)
void OptimalSolverLN::printStats(ostream& stream) {
	unsigned long long sumOfTravel = 0;
	stream << "divTravel distribution: ";
	for (int i = 0; i < readLength; i++) {
		stream << divTravel[i] << " ";
		sumOfTravel += divTravel[i] * i;
	}
	stream << endl;

	unsigned long long prefixesPerRead = (readLength + 1 - seedNum * minLength) * (seedNum - 2) + 1;
	unsigned long long totalPrefixes = processedReads * prefixesPerRead;
	stream << "divTravel per prefix: " << (double) sumOfTravel / totalPrefixes << endl;
	stream << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6371(%rip), %rsi      # 0xc323
movl $0x18, %edx
movq %rbx, %rdi
callq 0x32e0
cmpl $0x0, 0x360(%r14)
jle 0x6042
xorl %r12d, %r12d
leaq 0x664b(%rip), %r15      # 0xc61e
xorl %r13d, %r13d
movq 0x3e8(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x31a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
movq 0x3e8(%r14), %rax
movq (%rax,%r12,8), %rax
imulq %r12, %rax
addq %rax, %r13
incq %r12
movslq 0x360(%r14), %rax
cmpq %rax, %r12
jl 0x5fd6
movq %r13, %xmm0
punpckldq 0x60a9(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x60b1(%rip), %xmm0     # 0xc0e0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
jmp 0x604b
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
movl 0x360(%r14), %eax
movl 0x364(%r14), %ecx
movl 0x368(%r14), %edx
imull %ecx, %edx
negl %edx
addl %edx, %eax
incl %eax
addl $-0x2, %ecx
imull %eax, %ecx
incl %ecx
movslq %ecx, %rax
movl 0x400(%r14), %r14d
imulq %rax, %r14
leaq 0x628f(%rip), %rsi      # 0xc33c
movl $0x16, %edx
movq %rbx, %rdi
callq 0x32e0
movq %r14, %xmm0
punpckldq 0x6009(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6011(%rip), %xmm0     # 0xc0e0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
divsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O1/patxitron[P]BattleyeRconToolLinux/a3s.cpp
// Function: patxi::a3s::login(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void a3s::login(std::string const& password)
{
	if(!listening_) {
		send_request(password.data(), password.size(), LOGIN);
		listening_ = true;
		receive();
	}
}

// Assembly:
cmpb $0x0, 0x1(%rdi)
je 0x6cc7
retq
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
movl $0x1, %ecx
callq 0x6cec
movb $0x1, 0x1(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6ed6
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/Demo.cpp
// Function: main
int main(int argc, char* argv[]) {
    Scene scene;
    generateWorld(scene);
    
    //Make a 2x2 sampling
    int samps = (argc==2 ? atoi(argv[1])/4 : 1);
    //Initialize the camera
    Ray camera(Vec3d(50, 52, 295.6), Vec3d(0, -0.042612, -1).norm());
    
    //Start the ray tracing
    engine::raytracing(&scene, samps, camera, w, h, "result.ppm");
    
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movl %edi, %ebp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x5b98
movq %rbx, %rdi
callq 0x234c
movl $0x1, %ebx
cmpl $0x2, %ebp
jne 0x2f28
movq 0x8(%r14), %rdi
callq 0x2170
leal 0x3(%rax), %ebx
testl %eax, %eax
cmovnsl %eax, %ebx
sarl $0x2, %ebx
movabsq $0x4049000000000000, %rax # imm = 0x4049000000000000
movq %rax, 0x8(%rsp)
movabsq $0x404a000000000000, %rax # imm = 0x404A000000000000
movq %rax, 0x10(%rsp)
movabsq $0x407279999999999a, %rax # imm = 0x407279999999999A
movq %rax, 0x18(%rsp)
leaq 0xb8(%rsp), %rdi
movq $0x0, (%rdi)
movabsq $-0x405a2ec28b2a6b0e, %rax # imm = 0xBFA5D13D74D594F2
movq %rax, 0x8(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%rdi)
callq 0x5f8a
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x5e44
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5b70
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5e44
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x5e44
leaq 0x4070(%rip), %r9       # 0x7044
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movl %ebx, %esi
movl $0x400, %ecx            # imm = 0x400
movl $0x300, %r8d            # imm = 0x300
callq 0x3a2b
leaq 0x20(%rsp), %rdi
callq 0x5ba4
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x300c
jmp 0x300c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5ba4
movq %rbx, %rdi
callq 0x21c0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::destroy()
void ObjParser::destroy() {
    if (verticeList)
        delete [] verticeList;
    if (faceList)
        delete [] faceList;
        
    numOfVertices = -1;
    numOfFaces = -1;
    verticeList = NULL;
    faceList = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4223
callq 0x2140
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4235
callq 0x2140
movq $-0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::readFromObj(char const*)
bool ObjParser::readFromObj(const char* filename) {
    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        printf("RTError: The file %s doesn't exist.\n", filename);
        return false;
    } else {
        if (parse(fp)) {
            printf("Read from %s successfully.\n", filename);
            printf("Vertex Number = %d\n", numOfVertices);
            printf("Face Number = %d\n", numOfFaces);
            fclose(fp);
            return true;
        } else {
            printf("RTError: Cannot parse %s.\n", filename);
            fclose(fp);
            return false;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2ef3(%rip), %rsi      # 0x7153
movq %r14, %rdi
callq 0x2130
testq %rax, %rax
je 0x42c0
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x42fe
testb %al, %al
je 0x42d5
leaq 0x2ef4(%rip), %rdi      # 0x717a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movl (%r15), %esi
leaq 0x2efc(%rip), %rdi      # 0x7196
xorl %eax, %eax
callq 0x2040
movl 0x4(%r15), %esi
leaq 0x2efe(%rip), %rdi      # 0x71aa
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
callq 0x2100
movb $0x1, %bpl
jmp 0x42f0
leaq 0x2e8e(%rip), %rdi      # 0x7155
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x42f0
leaq 0x2ee0(%rip), %rdi      # 0x71bc
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
callq 0x2100
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop