LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/ChronoCpu.cpp
// Function: ChronoCpu::doTic()
void ChronoCpu::doTic(void)
{
	lastTicTime = ticTime;

#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ticTime.tv_sec = mts.tv_sec;
	ticTime.tv_nsec = mts.tv_nsec;

#else
	if (clock_gettime(CLOCK_REALTIME, &ticTime) != 0){
		++errors;
		cerr << "ChronoCpu::doTic - " << name << ": clock_gettime() failed!" << endl;
		return;
	}
#endif

	++ticCounter;

	if (ticCounter > 1){
		float period_s = (float)(ticTime.tv_sec - lastTicTime.tv_sec);
		float period_ns = (float)(ticTime.tv_nsec - lastTicTime.tv_nsec);
		periodStats.lastTime_ms = period_s * 1e3f + period_ns / 1e6f;
		updateStats(periodStats);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc0(%rdi), %rsi
movups 0xc0(%rdi), %xmm0
movups %xmm0, 0xb0(%rdi)
xorl %edi, %edi
callq 0x4330
testl %eax, %eax
je 0x11b54
incl 0x2c(%rbx)
movq 0x7502(%rip), %r14      # 0x18ff0
leaq 0x2373(%rip), %rsi      # 0x13e68
movl $0x13, %edx
movq %r14, %rdi
callq 0x43f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0x2360(%rip), %rsi      # 0x13e7c
movl $0x19, %edx
movq %rax, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4260
movl 0xe0(%rbx), %eax
incl %eax
movl %eax, 0xe0(%rbx)
cmpl $0x2, %eax
jb 0x11bbc
movq 0xc0(%rbx), %rax
subq 0xb0(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movq 0xc8(%rbx), %rax
subq 0xb8(%rbx), %rax
cvtsi2ss %rax, %xmm1
divss 0x22c8(%rip), %xmm1     # 0x13e60
mulss 0x22c4(%rip), %xmm0     # 0x13e64
addss %xmm1, %xmm0
leaq 0x70(%rbx), %rsi
movss %xmm0, 0xa4(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x124f8
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/ChronoCpu.cpp
// Function: ChronoCpu::doTac()
void ChronoCpu::doTac(void)
{
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	tacTime.tv_sec = mts.tv_sec;
	tacTime.tv_nsec = mts.tv_nsec;

#else
	if (clock_gettime(CLOCK_REALTIME, &tacTime) != 0){
		++errors;
		cerr << "ChronoCpu::doTac - " << name << ": clock_gettime() failed!" << endl;
		return;
	}
#endif

	float elapsed_s = (float)(tacTime.tv_sec - ticTime.tv_sec);
	float elapsed_ns = (float)(tacTime.tv_nsec - ticTime.tv_nsec);
	elapsedStats.lastTime_ms = elapsed_s * 1e3f + elapsed_ns / 1e6f;
	updateStats(elapsedStats);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xd0(%rdi), %rsi
xorl %edi, %edi
callq 0x4330
testl %eax, %eax
je 0x11c4e
incl 0x2c(%rbx)
movq 0x7408(%rip), %r14      # 0x18ff0
leaq 0x22a7(%rip), %rsi      # 0x13e96
movl $0x13, %edx
movq %r14, %rdi
callq 0x43f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0x2266(%rip), %rsi      # 0x13e7c
movl $0x19, %edx
movq %rax, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4260
movq 0xd0(%rbx), %rax
subq 0xc0(%rbx), %rax
cvtsi2ss %rax, %xmm0
movq 0xd8(%rbx), %rax
subq 0xc8(%rbx), %rax
cvtsi2ss %rax, %xmm1
divss 0x21e4(%rip), %xmm1     # 0x13e60
mulss 0x21e0(%rip), %xmm0     # 0x13e64
addss %xmm1, %xmm0
leaq 0x30(%rbx), %rsi
movss %xmm0, 0x64(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x124f8
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Chrono.cpp
// Function: Chrono::tic()
void Chrono::tic(void)
{
	if (!enabled){
		return;
	}

	if (ticIdle){
		ticIdle = false;
		doTic();
	} else{
		++errors;
		cerr << "Chrono::tic - " << name << ": Calling Chrono::tic with no matching Chrono::tag!" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x11e6b
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0x11e70
movb $0x0, 0x29(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
incl 0x2c(%rbx)
movq 0x7176(%rip), %r14      # 0x18ff0
leaq 0x2054(%rip), %rsi      # 0x13ed5
movl $0xe, %edx
movq %r14, %rdi
callq 0x43f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0x203c(%rip), %rsi      # 0x13ee4
movl $0x33, %edx
movq %rax, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4260
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Chrono.cpp
// Function: Chrono::tac()
void Chrono::tac(void)
{
	if (!enabled){
		return;
	}

	if (!ticIdle){
		ticIdle = true;
		doTac();
	} else{
		++errors;
		cerr << "Chrono::tac - " << name << ": Calling Chrono::tac with no matching Chrono::tic!" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x11f66
movq %rdi, %rbx
cmpb $0x0, 0x29(%rdi)
je 0x11f6b
incl 0x2c(%rbx)
movq 0x70f0(%rip), %r14      # 0x18ff0
leaq 0x2011(%rip), %rsi      # 0x13f18
movl $0xe, %edx
movq %r14, %rdi
callq 0x43f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0x1ff9(%rip), %rsi      # 0x13f27
movl $0x33, %edx
movq %rax, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4260
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, 0x29(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Chrono.cpp
// Function: Chrono::printAvgTime(Chrono::ChronoStats const&, std::ostream&) const
std::ostream& Chrono::printAvgTime(const Chrono::ChronoStats& stats, std::ostream& os) const
{
	os.precision(2);
	os << fixed;
	os << name << ": " << stats.name << " -> " << "averageTime: " << stats.averageTime_ms << " [ms]" << endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x8(%rdx,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rdx,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rdx,%rax)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r15
leaq 0x1117(%rip), %rsi      # 0x13443
movl $0x2, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x43f0
movq %rax, %r15
leaq 0x1c65(%rip), %rsi      # 0x13fb7
movl $0x4, %edx
movq %rax, %rdi
callq 0x43f0
leaq 0x1c13(%rip), %rsi      # 0x13f79
movl $0xd, %edx
movq %r15, %rdi
callq 0x43f0
cvtss2sd 0x2c(%r14), %xmm0
movq %r15, %rdi
callq 0x4560
movq %rax, %r14
leaq 0x1be7(%rip), %rsi      # 0x13f72
movl $0x5, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Chrono.cpp
// Function: Chrono::printAvgTime(Chrono::ChronoStats const&, std::ostream&, float) const
std::ostream& Chrono::printAvgTime(const Chrono::ChronoStats& stats, std::ostream& os, const float ref) const
{
	os.precision(2);
	os << fixed;
	os << name << ": " << stats.name << " -> " << "averageTime: " << stats.averageTime_ms << " [ms] (";
	os << (stats.averageTime_ms/ref*100.0f) << "%)" << endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, -0x1c(%rbp)
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x8(%rdx,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rdx,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rdx,%rax)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r15
leaq 0x1022(%rip), %rsi      # 0x13443
movl $0x2, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x43f0
movq %rax, %r15
leaq 0x1b70(%rip), %rsi      # 0x13fb7
movl $0x4, %edx
movq %rax, %rdi
callq 0x43f0
leaq 0x1b1e(%rip), %rsi      # 0x13f79
movl $0xd, %edx
movq %r15, %rdi
callq 0x43f0
xorps %xmm0, %xmm0
cvtss2sd 0x2c(%r14), %xmm0
movq %r15, %rdi
callq 0x4560
leaq 0x1b3c(%rip), %rsi      # 0x13fbc
movl $0x7, %edx
movq %rax, %rdi
callq 0x43f0
movss 0x2c(%r14), %xmm0
divss -0x1c(%rbp), %xmm0
mulss 0x1a18(%rip), %xmm0     # 0x13eb8
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq 0x1b0e(%rip), %rsi      # 0x13fc4
movl $0x2, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Chrono.cpp
// Function: Chrono::updateStats(Chrono::ChronoStats&)
void Chrono::updateStats(ChronoStats& stats)
{
	++stats.counter;
	stats.totalTime_ms += stats.lastTime_ms;
	stats.totalSquaredTime_ms2 += stats.lastTime_ms * stats.lastTime_ms;
	stats.averageTime_ms = stats.totalTime_ms / (float)stats.counter;
	stats.stdDevTime_ms = sqrtf(stats.totalSquaredTime_ms2 / (float)stats.counter - stats.averageTime_ms * stats.averageTime_ms);
	if (stats.counter > 1){
		stats.maxTime_ms = max(stats.lastTime_ms, stats.maxTime_ms);
		stats.minTime_ms = min(stats.lastTime_ms, stats.minTime_ms);
	} else{
		stats.maxTime_ms = stats.lastTime_ms;
		stats.minTime_ms = stats.lastTime_ms;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x20(%rsi), %eax
incl %eax
movl %eax, 0x20(%rsi)
movss 0x34(%rsi), %xmm0
movss 0x24(%rsi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x24(%rsi)
mulss %xmm0, %xmm0
addss 0x28(%rsi), %xmm0
movss %xmm0, 0x28(%rsi)
cvtsi2ss %rax, %xmm2
divss %xmm2, %xmm1
movss %xmm1, 0x2c(%rsi)
divss %xmm2, %xmm0
mulss %xmm1, %xmm1
subss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x12552
sqrtss %xmm0, %xmm0
jmp 0x12557
callq 0x4670
movss %xmm0, 0x30(%rbx)
cmpl $0x2, 0x20(%rbx)
jb 0x12585
movss 0x3c(%rbx), %xmm0
movss 0x34(%rbx), %xmm1
movss 0x38(%rbx), %xmm2
maxss %xmm1, %xmm0
movss %xmm0, 0x3c(%rbx)
minss %xmm1, %xmm2
movss %xmm2, 0x38(%rbx)
jmp 0x12594
movss 0x34(%rbx), %xmm0
movss %xmm0, 0x3c(%rbx)
movss %xmm0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/main.cpp
// Function: main
int main(int argc, char **argv)
{
	const char *config_fn, *pipe_fn;

	// Read arguments from command line, or take the defaults
	config_fn = (argc > 1) ? argv[1] : "throttle.conf";
	pipe_fn = (argc > 2) ? argv[2] : "pipe";

	// Block SIGINT, SIGQUIT, SIGTERM - we're going to wait for them explicitly.
	sigset_t signals;
	sigemptyset(&signals);
	sigaddset(&signals, SIGINT);
	sigaddset(&signals, SIGQUIT);
	sigaddset(&signals, SIGTERM);
	sigprocmask(SIG_BLOCK, &signals, nullptr);

	constexpr struct timespec wait_time{wait, 0};

	try {
		// create Throttle object
		Throttle throttle = Throttle::createFromConfig(config_fn, pipe_fn);

		// Run the feedback loop
		do
			throttle();
		while (sigtimedwait(&signals, nullptr, &wait_time) == -1);
	}
	catch (const std::runtime_error& ex) {
		std::cerr << "Error: " <<  ex.what() << std::endl;
		return 1;
	}

	DEBUG_PRINT("[Main] Successful shutdown");

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
leaq 0x2c56(%rip), %rbx      # 0x5165
cmpl $0x2, %edi
jl 0x2520
movq 0x8(%rsi), %r14
je 0x2527
movq 0x10(%rsi), %rbx
jmp 0x2527
leaq 0x2add(%rip), %r14      # 0x5004
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
callq 0x2220
movq %r15, %rdi
movl $0x2, %esi
callq 0x2280
movq %r15, %rdi
movl $0x3, %esi
callq 0x2280
movq %r15, %rdi
movl $0xf, %esi
callq 0x2280
xorl %edi, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20d0
movups 0x2aaf(%rip), %xmm0     # 0x5020
movaps %xmm0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x28b8
leaq 0x10(%rsp), %rbx
leaq 0xa0(%rsp), %r14
movq %rsp, %r15
movq %rbx, %rdi
callq 0x2c3e
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2110
cmpl $-0x1, %eax
je 0x2595
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d64
movq -0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x25d5
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x26e2
movq -0x28(%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x25fd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x2624
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2692
cmpl $0x1, %r14d
jne 0x2681
movq %rbx, %rdi
callq 0x20b0
movq %rax, %rbx
movq 0x59ac(%rip), %rdi      # 0x7fe8
leaq 0x29cf(%rip), %rsi      # 0x5012
movl $0x7, %edx
callq 0x2210
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x598b(%rip), %rdi      # 0x7fe8
movq %rax, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20e0
callq 0x22e0
movl $0x1, %eax
jmp 0x25ff
movq %rax, %rbx
callq 0x22e0
movq %rbx, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x26d7
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.cpp
// Function: Throttle::FreqFilenames::FreqFilenames(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
Throttle::FreqFilenames::FreqFilenames(
	const std::string &prefix, const std::string &suffix, unsigned numCores)
	: numCores(numCores), templates(log10(numCores) + 1), prefix_size(prefix.size())
{
	size_t suffix_size = suffix.size();
	for (unsigned i = 0; i != templates.size(); ++i) {
		templates[i].reserve(prefix_size + (i + 1) + suffix_size);
		templates[i] = prefix;
		templates[i].append(i + 1, '#');
		templates[i] += suffix;
		DEBUG_PRINT("[Throttle] Template for length " << i + 1 << ": " << templates[i]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movl %ecx, (%rdi)
leaq 0x8(%rdi), %rbx
movl $0x1, %esi
cmpl $0xa, %ecx
jb 0x2788
movl $0x1, %eax
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ecx, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
incl %eax
cmpl $0x63, %ecx
movl %esi, %ecx
ja 0x2773
movl %eax, %esi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2e82
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%r12)
movq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %r15d
leal -0x1(%r15), %r13d
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
je 0x282b
shlq $0x5, %r13
addq %r13, %rdi
movl %r15d, %ebp
movq 0x10(%rsp), %rax
leaq (%rax,%rbp), %rsi
addq 0x20(%r12), %rsi
callq 0x22a0
movq (%rbx), %rdi
addq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x2120
movq (%rbx), %rdi
movq 0x8(%rdi,%r13), %rsi
addq %r13, %rdi
xorl %edx, %edx
movq %rbp, %rcx
movl $0x23, %r8d
callq 0x2360
addq (%rbx), %r13
movq (%r14), %rsi
movq 0x8(%r14), %rdx
incl %r15d
movq %r13, %rdi
callq 0x2070
jmp 0x27b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x26e2
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.cpp
// Function: Throttle::FreqFilenames::operator[](unsigned int) const
const char *Throttle::FreqFilenames::operator[](unsigned core) const
{
	unsigned bucket = log10(core);
	std::string &ret = templates[bucket];
	unsigned print = core;
	do {
		ret[prefix_size + bucket] = '0' + char(print % 10);
		print /= 10;
	} while (bucket--);
	DEBUG_PRINT("[Throttle] Filename for core " << core << ": " << ret);
	return ret.c_str();
}

// Assembly:
xorl %eax, %eax
cmpl $0xa, %esi
jb 0x2873
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %esi, %edx
movl %edx, %r8d
imulq %rcx, %r8
shrq $0x23, %r8
incl %eax
cmpl $0x63, %edx
movl %r8d, %edx
ja 0x285c
movl %eax, %eax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%rdi), %rcx
incq %rax
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %esi, %r8d
imulq %rdx, %r8
shrq $0x23, %r8
leal (%r8,%r8), %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %esi
movq (%rcx), %r9
addq 0x20(%rdi), %r9
orb $0x30, %sil
movb %sil, -0x1(%rax,%r9)
movl %r8d, %esi
decq %rax
jne 0x2886
movq (%rcx), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.cpp
// Function: Throttle::operator()()
void Throttle::operator()()
{
	// Look if there is new input in the pipe
	queue.update();

	if (override_freq) {
		if (freq != override_freq) {
			freq = override_freq;
			writeFreq();
		}
	}
	else
		adjust();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x78, %rdi
callq 0x3d78
movl 0x88(%rbx), %eax
testl %eax, %eax
je 0x2c5c
cmpl %eax, 0x68(%rbx)
jne 0x2c65
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x2d1e
movl %eax, 0x68(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2c72
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.cpp
// Function: Throttle::writeFreq() const
void Throttle::writeFreq() const
{
	DEBUG_PRINT("[Throttle] New frequency: " << (float)freq/1000 << " MHz");

	// loop over the files, write the frequency in each
       for (unsigned core = 0; core != freq_fn.size(); ++core) {
		std::ofstream freq_file(freq_fn[core]);
		freq_file << freq;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
cmpl $0x0, 0x20(%rdi)
je 0x2cf6
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x5321(%rip), %rax      # 0x7fb8
movq (%rax), %r15
movq 0x18(%rax), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x284e
movq %r13, %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x2200
movl 0x68(%rbx), %esi
movq %r13, %rdi
callq 0x2310
movq %r15, 0x8(%rsp)
movq -0x18(%r15), %rax
movq %r12, 0x8(%rsp,%rax)
leaq 0x10(%rsp), %rdi
callq 0x21a0
leaq 0x100(%rsp), %rdi
callq 0x2080
incl %ebp
cmpl (%r14), %ebp
jne 0x2ca5
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.cpp
// Function: Throttle::adjust()
void Throttle::adjust()
{
	int temp = readTemp();
	std::vector<int>::const_iterator new_freq = freqs.end();

	DEBUG_PRINT("[Throttle] Temperature: " << (float)temp/1000 << "°C");

	// slowly reset stabilize counter
	if (stabilize > 0) --stabilize;
	if (stabilize < 0) ++stabilize;

	// If the temperature exceeds a threshold, find the next best frequency.
	if (temp > temp_max && stabilize >= 0) {
		new_freq = std::lower_bound(freqs.begin(), freqs.end(), freq);
		if (new_freq == freqs.begin())
			return;     // There is nothing we can do.
		else
			--new_freq;
		stabilize = -wait_after_adjust;
	}
	if (temp < temp_min && stabilize <= 0) {
		new_freq = std::upper_bound(freqs.begin(), freqs.end(), freq);
		stabilize = wait_after_adjust;
	}

	// Have we found one? Then adjust.
	if (new_freq != freqs.end()) {
		freq = *new_freq;
		writeFreq();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2e2a
movl 0x70(%rbx), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x2d3c
addl %edx, %ecx
movl %ecx, 0x70(%rbx)
movl %ecx, %esi
jmp 0x2d46
xorl %esi, %esi
testl %ecx, %ecx
js 0x2e1f
movq 0x58(%rbx), %rcx
cmpl 0x48(%rbx), %eax
setg %dl
testl %esi, %esi
setns %dil
andb %dl, %dil
movq %rcx, %rdx
cmpb $0x1, %dil
jne 0x2dbb
movq 0x50(%rbx), %rsi
movq %rcx, %r8
subq %rsi, %r8
sarq $0x2, %r8
testq %r8, %r8
jle 0x2e1d
movl 0x68(%rbx), %edi
movq %rsi, %rdx
movq %r8, %r9
shrq %r9
movq %r9, %r10
notq %r10
addq %r8, %r10
leaq (%rdx,%r9,4), %r8
addq $0x4, %r8
cmpl %edi, -0x4(%r8)
cmovlq %r8, %rdx
cmovgeq %r9, %r10
movq %r10, %r8
testq %r10, %r10
jg 0x2d7f
cmpq %rsi, %rdx
je 0x2e1d
addq $-0x4, %rdx
xorl %esi, %esi
subl 0x6c(%rbx), %esi
movl %esi, 0x70(%rbx)
cmpl 0x4c(%rbx), %eax
jge 0x2e0a
testl %esi, %esi
jg 0x2e0a
movq 0x50(%rbx), %rdx
movq %rcx, %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
testq %rsi, %rsi
jle 0x2e04
movl 0x68(%rbx), %eax
movq %rsi, %rdi
shrq %rdi
movq %rdi, %r8
notq %r8
addq %rsi, %r8
leaq (%rdx,%rdi,4), %rsi
addq $0x4, %rsi
cmpl -0x4(%rsi), %eax
cmovgeq %rsi, %rdx
cmovlq %rdi, %r8
movq %r8, %rsi
testq %r8, %r8
jg 0x2dda
movl 0x6c(%rbx), %eax
movl %eax, 0x70(%rbx)
cmpq %rcx, %rdx
je 0x2e1d
movl (%rdx), %eax
movl %eax, 0x68(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2c72
popq %rbx
retq
movl $0x1, %edx
jmp 0x2d33
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.hpp
// Function: Conf::Parser<std::vector<int, std::allocator<int>>>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<T> Conf::Parser<std::vector<T>>::parse(const std::string &str)
{
	std::istringstream stream(str);

	std::vector<T> ret;
	T cur;
	while (stream >> cur)
		ret.push_back(cur);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x30bc
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x30af
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x307c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3128
jmp 0x307c
movq 0x4efd(%rip), %rsi      # 0x7fc0
leaq 0x10(%rsp), %rdi
callq 0x2240
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3101
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq 0x4eb8(%rip), %rsi      # 0x7fc0
leaq 0x10(%rsp), %rdi
callq 0x2240
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/throttle.hpp
// Function: Conf::Parser<unsigned int>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T Conf::Parser<T>::parse(const std::string &str)
{
	T ret;
	std::istringstream stream(str);
	stream >> ret;
	return ret;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x22f0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x2320
movl 0xc(%rsp), %ebx
movq 0x49f9(%rip), %rsi      # 0x7fc0
leaq 0x10(%rsp), %rdi
callq 0x2240
leaq 0x88(%rsp), %rdi
callq 0x2080
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x49cd(%rip), %rsi      # 0x7fc0
leaq 0x10(%rsp), %rdi
callq 0x2240
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/conf.cpp
// Function: Conf::GetAttr[abi:cxx11](char const*) const
const std::string& Conf::GetAttr(const char *name) const
{
	auto it = std::find_if(attributes.begin(), attributes.end(),
		[name](const std::pair<std::string, std::string>& p)
		{
			return p.first == name;
		});

	if (it != attributes.end())
		return it->second;
	else
		throw std::runtime_error(std::string("No such attribute: ") + name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r13
movq %r13, (%rsp)
subq %r15, %r13
movq %r13, %rbp
sarq $0x8, %rbp
testq %rbp, %rbp
jle 0x3a60
incq %rbp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3ab3
leaq 0x40(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3abc
leaq 0x80(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3abc
leaq 0xc0(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3abc
addq $0x100, %r15            # imm = 0x100
decq %rbp
addq $-0x100, %r13
cmpq $0x1, %rbp
jg 0x39ef
sarq $0x6, %r13
cmpq $0x1, %r13
je 0x3a9c
cmpq $0x2, %r13
je 0x3a89
cmpq $0x3, %r13
jne 0x3ab8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3ab3
addq $0x40, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
je 0x3ab3
addq $0x40, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2060
testl %eax, %eax
movq (%rsp), %r12
cmoveq %r15, %r12
jmp 0x3abc
movq %r15, %r12
jmp 0x3abc
movq (%rsp), %r12
cmpq 0x8(%r14), %r12
je 0x3ad8
addq $0x20, %r12
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x161d(%rip), %rsi      # 0x5112
leaq 0x1629(%rip), %rdx      # 0x5125
leaq 0x8(%rsp), %rdi
callq 0x40b6
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2370
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3b36
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x3b43
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x22c0
xorl %ebp, %ebp
movq 0x447d(%rip), %rsi      # 0x7ff0
movq 0x444e(%rip), %rdx      # 0x7fc8
movq %r14, %rdi
callq 0x2300
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b9c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3bb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
testb %bpl, %bpl
jne 0x3bd9
jmp 0x3be1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3bd9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x3bd9
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/conf.cpp
// Function: CommQueue::CommQueue(Throttle*, char const*)
CommQueue::CommQueue(Throttle *parent, const char *pipe_fn) : Throt(parent)
{
	// Open the command pipe
	comm_file = open(pipe_fn, O_RDONLY | O_NONBLOCK);

	if (comm_file < 0)
		throw std::runtime_error(std::string("Couldn't open command pipe '") + pipe_fn + '\'');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, %rdi
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
callq 0x2170
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0x3c22
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14e7(%rip), %rsi      # 0x5126
leaq 0x14fc(%rip), %rdx      # 0x5142
movq %rsp, %rdi
callq 0x40b6
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2370
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3c7c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x3c89
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movl $0x27, %edx
callq 0x4012
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x22c0
xorl %ebp, %ebp
movq 0x4323(%rip), %rsi      # 0x7ff0
movq 0x42f4(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d02
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x3d02
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x3d19
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3d2f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
testb %bpl, %bpl
jne 0x3d54
jmp 0x3d5c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3d54
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x3d54
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/conf.cpp
// Function: CommQueue::update()
void CommQueue::update()
{
	char buf[LINE_LENGTH];
	ssize_t ret;
	while (true) {
		ret = read(comm_file, buf, LINE_LENGTH-1);
		if (ret <= 0)
			break;
		processCommand(std::string(buf, ret));
	}

	// This should be because there's nothing more to read
	if (ret != 0 && errno != EAGAIN)
		throw std::runtime_error("Read error while checking command pipe");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rdi, %rbx
movl 0x8(%rdi), %edi
leaq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x2250
testq %rax, %rax
jle 0x3dfa
leaq 0x10(%rsp), %r12
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq %r12, (%rsp)
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e7e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3de5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movl 0x8(%rbx), %edi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r15, %rsi
callq 0x2250
testq %rax, %rax
jg 0x3dad
testq %rax, %rax
je 0x3e09
callq 0x2030
cmpl $0xb, (%rax)
jne 0x3e18
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
leaq 0x1317(%rip), %rsi      # 0x5143
movq %rax, %rdi
callq 0x20a0
movq 0x41b5(%rip), %rsi      # 0x7ff0
movq 0x4186(%rip), %rdx      # 0x7fc8
movq %r14, %rdi
callq 0x2300
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
jmp 0x3e75
movq %rax, %rbx
jmp 0x3e75
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronpuchert[P]throttle/src/conf.cpp
// Function: CommQueue::processCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CommQueue::processCommand(const std::string &comm)
{
	std::istringstream stream(comm);

	std::string command;
	stream >> command;

	if (command == "min") {
		int temp;
		stream >> temp;
		Throt->setMinTemp(temp);
		DEBUG_PRINT("[CommQueue] Set minimum temperature to " << temp);
	}
	else if (command == "max") {
		int temp;
		stream >> temp;
		Throt->setMaxTemp(temp);
		DEBUG_PRINT("[CommQueue] Set maximum temperature to " << temp);
	}
	else if (command == "freq") {
		int freq;
		stream >> freq;
		Throt->setOverrideFreq(freq);
		DEBUG_PRINT("[CommQueue] Set frequency to " << freq);
	}
	else if (command == "reset") {
		Throt->setOverrideFreq(0);
		DEBUG_PRINT("[CommQueue] Reset mechanism");
	}
	else {
		DEBUG_PRINT("[CommQueue] Ignored unknown command: " << command);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x2230
leaq 0x11ac(%rip), %rsi      # 0x5074
leaq 0x10(%rsp), %rdi
callq 0x2060
testl %eax, %eax
je 0x3f25
leaq 0x11a0(%rip), %rsi      # 0x507d
leaq 0x10(%rsp), %rdi
callq 0x2060
testl %eax, %eax
je 0x3f44
leaq 0x1278(%rip), %rsi      # 0x516a
leaq 0x10(%rsp), %rdi
callq 0x2060
testl %eax, %eax
je 0x3f63
leaq 0x1268(%rip), %rsi      # 0x516f
leaq 0x10(%rsp), %rdi
callq 0x2060
testl %eax, %eax
jne 0x3f8a
movq (%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x88(%rax)
movl %ecx, 0x70(%rax)
jmp 0x3f8a
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2130
movq (%rbx), %rax
imull $0x3e8, 0xc(%rsp), %ecx # imm = 0x3E8
movl %ecx, 0x4c(%rax)
jmp 0x3f8a
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2130
movq (%rbx), %rax
imull $0x3e8, 0xc(%rsp), %ecx # imm = 0x3E8
movl %ecx, 0x48(%rax)
jmp 0x3f8a
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2130
movq (%rbx), %rax
imull $0x3e8, 0xc(%rsp), %ecx # imm = 0x3E8
movl %ecx, 0x88(%rax)
movl $0x0, 0x70(%rax)
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3fa1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x4018(%rip), %rsi      # 0x7fc0
leaq 0x30(%rsp), %rdi
callq 0x2240
leaq 0xa8(%rsp), %rdi
callq 0x2080
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3fd2
jmp 0x3fd2
jmp 0x3fd2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3fec
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x3fcd(%rip), %rsi      # 0x7fc0
leaq 0x30(%rsp), %rdi
callq 0x2240
leaq 0xa8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bamtk.c
// Function: main.cold.1
static int usage()
{
	fprintf(stderr, "\n");
	fprintf(stderr, "Program: samtools (Tools for alignments in the SAM format)\n");
	fprintf(stderr, "Version: %s\n\n", PACKAGE_VERSION);
	fprintf(stderr, "Usage:   samtools <command> [options]\n\n");
	fprintf(stderr, "Command: view        SAM<->BAM conversion\n");
	fprintf(stderr, "         sort        sort alignment file\n");
	fprintf(stderr, "         pileup      generate pileup output\n");
	fprintf(stderr, "         faidx       index/extract FASTA\n");
#if _CURSES_LIB != 0
	fprintf(stderr, "         tview       text alignment viewer\n");
#endif
	fprintf(stderr, "         index       index alignment\n");
	fprintf(stderr, "         fixmate     fix mate information\n");
	fprintf(stderr, "         glfview     print GLFv3 file\n");
	fprintf(stderr, "         flagstat    simple stats\n");
	fprintf(stderr, "         calmd       recalculate MD/NM tags, also BAQ adjustment around indels\n");
	fprintf(stderr, "         merge       merge sorted alignments\n");
	fprintf(stderr, "         rmdup       remove PCR duplicates\n");
	fprintf(stderr, "\n");
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x2a37d(%rip), %r13     # 0x2dfe8
movq (%r13), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x3290
movq (%r13), %rcx
leaq 0x211d6(%rip), %rdi     # 0x24e5a
pushq $0x3b
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x3600
movq (%r13), %rdi
leaq 0x211f8(%rip), %rsi     # 0x24e96
leaq 0x211ff(%rip), %rdx     # 0x24ea4
xorl %eax, %eax
callq 0x3630
movq (%r13), %rcx
leaq 0x21208(%rip), %rdi     # 0x24ebf
pushq $0x27
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x2121a(%rip), %rdi     # 0x24ee7
pushq $0x2a
popq %r12
movq %r12, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x2122b(%rip), %rdi     # 0x24f12
pushq $0x29
popq %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x2123b(%rip), %rdi     # 0x24f3c
pushq $0x2c
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x21252(%rip), %rdi     # 0x24f69
movq %r15, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x21266(%rip), %rdi     # 0x24f93
pushq $0x2b
popq %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x21278(%rip), %rdi     # 0x24fbf
pushq $0x25
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x21288(%rip), %rdi     # 0x24fe5
movq %r12, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x2129d(%rip), %rdi     # 0x25010
pushq $0x26
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x212ae(%rip), %rdi     # 0x25037
pushq $0x22
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x212bb(%rip), %rdi     # 0x2505a
pushq $0x4f
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x212f5(%rip), %rdi     # 0x250aa
pushq $0x2d
popq %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rcx
leaq 0x2130d(%rip), %rdi     # 0x250d8
movq %r15, %rsi
movq %r14, %rdx
callq 0x3600
movq (%r13), %rsi
movl %ebx, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3290
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_tview.c
// Function: tv_destroy
void tv_destroy(tview_t *tv)
{
	delwin(tv->wgoto); delwin(tv->whelp);
	endwin();

	bam_lplbuf_destroy(tv->lplbuf);
	bam_maqcns_destroy(tv->bmc);
	bam_index_destroy(tv->idx);
	if (tv->fai) fai_destroy(tv->fai);
	free(tv->ref);
	bam_header_destroy(tv->header);
	bam_close(tv->fp);
	free(tv);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3390
movq 0x10(%rbx), %rdi
callq 0x3390
callq 0x34d0
movq 0x20(%rbx), %rdi
callq 0x18f00
movq 0x48(%rbx), %rdi
callq 0x743e
movq 0x18(%rbx), %rdi
callq 0x16092
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x5c83
callq 0x1b2fd
movq 0x78(%rbx), %rdi
callq 0x32c0
movq 0x28(%rbx), %rdi
callq 0x122ff
movq 0x30(%rbx), %rdi
callq 0x10d25
movq %rbx, %rdi
popq %rbx
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_tview.c
// Function: tv_fetch_func
int tv_fetch_func(const bam1_t *b, void *data)
{
	tview_t *tv = (tview_t*)data;
	if (tv->no_skip) {
		uint32_t *cigar = bam1_cigar(b); // this is cheating...
		int i;
		for (i = 0; i <b->core.n_cigar; ++i) {
			if ((cigar[i]&0xf) == BAM_CREF_SKIP)
				cigar[i] = cigar[i]>>4<<4 | BAM_CDEL;
		}
	}
	bam_lplbuf_push(b, tv->lplbuf);
	return 0;
}

// Assembly:
pushq %rax
cmpl $0x0, 0x70(%rsi)
je 0x5cf2
movq 0x8(%rdi), %rax
movq %rax, %rcx
shrq $0x30, %rcx
je 0x5cf2
movl %eax, %ecx
shrl $0x18, %ecx
addq 0x30(%rdi), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %r8d
movl %r8d, %r9d
andl $0xf, %r9d
cmpl $0x3, %r9d
jne 0x5ce3
andl $-0xe, %r8d
movl %r8d, (%rcx,%rdx,4)
movq 0x8(%rdi), %rax
incq %rdx
movq %rax, %r8
shrq $0x30, %r8
cmpq %r8, %rdx
jb 0x5cc6
movq 0x20(%rsi), %rsi
callq 0x19097
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_tview.c
// Function: bam_tview_main
int bam_tview_main(int argc, char *argv[])
{
	tview_t *tv;
	if (argc == 1) {
		fprintf(stderr, "Usage: bamtk tview <aln.bam> [ref.fasta]\n");
		return 1;
	}
	tv = tv_init(argv[1], (argc == 2)? 0 : argv[2]);
	tv_draw_aln(tv, 0, 0);
	tv_loop(tv);
	tv_destroy(tv);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x65f2
movl %edi, %eax
movq 0x8(%rsi), %rdi
xorl %ebx, %ebx
cmpl $0x2, %eax
jne 0x65c0
xorl %esi, %esi
jmp 0x65c4
movq 0x10(%rsi), %rsi
callq 0x5a2b
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5cff
movq %r14, %rdi
callq 0x5ea8
movq %r14, %rdi
callq 0x5c3f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x36b0
movl $0x1, %ebx
jmp 0x65e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_maqcns.c
// Function: bam_maqcns_init
bam_maqcns_t *bam_maqcns_init()
{
	bam_maqcns_t *bm;
	bm = (bam_maqcns_t*)calloc(1, sizeof(bam_maqcns_t));
	bm->aux = (bmc_aux_t*)calloc(1, sizeof(bmc_aux_t));
	bm->het_rate = 0.001;
	bm->theta = 0.85;
	bm->n_hap = 2;
	bm->eta = 0.03;
	bm->cap_mapQ = 60;
	return bm;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x3530
movq %rax, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x3530
movq %rax, 0x38(%rbx)
movsd 0x1c77d(%rip), %xmm0    # 0x23470
movsd %xmm0, (%rbx)
movabsq $0x3c00000002, %rax     # imm = 0x3C00000002
movq %rax, 0x8(%rbx)
movl $0x3cf5c28f, 0x14(%rbx) # imm = 0x3CF5C28F
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_maqcns.c
// Function: bam_maqcns_call
uint32_t bam_maqcns_call(int n, const bam_pileup1_t *pl, bam_maqcns_t *bm)
{
	glf1_t *g;
	uint32_t x;
	if (n) {
		g = bam_maqcns_glfgen(n, pl, 0xf, bm);
		x = glf2cns(g, (int)(bm->q_r + 0.5));
		free(g);
	} else x = 0xfU<<28 | 0xfU<<24;
	return x;
}

// Assembly:
testl %edi, %edi
je 0x7ed1
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0xf, %edx
movq %rbx, %rcx
callq 0x7482
movq %rax, %r14
cvtss2sd 0x18(%rbx), %xmm0
addsd 0x1b647(%rip), %xmm0    # 0x234f8
cvttsd2si %xmm0, %esi
movq %rax, %rdi
callq 0x7d10
movl %eax, %ebx
movq %r14, %rdi
callq 0x32c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xff000000, %eax       # imm = 0xFF000000
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_maqcns.c
// Function: bam_tpos2qpos
int bam_tpos2qpos(const bam1_core_t *c, const uint32_t *cigar, int32_t tpos, int is_left, int32_t *_tpos)
{
	int k, x = c->pos, y = 0, last_y = 0;
	*_tpos = c->pos;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		int l = cigar[k] >> BAM_CIGAR_SHIFT;
		if (op == BAM_CMATCH) {
			if (c->pos > tpos) return y;
			if (x + l > tpos) {
				*_tpos = tpos;
				return y + (tpos - x);
			}
			x += l; y += l;
			last_y = y;
		} else if (op == BAM_CINS || op == BAM_CSOFT_CLIP) y += l;
		else if (op == BAM_CDEL || op == BAM_CREF_SKIP) {
			if (x + l > tpos) {
				*_tpos = is_left? x : x + l;
				return y;
			}
			x += l;
		}
	}
	*_tpos = x;
	return last_y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x4(%rdi), %r9d
movl %r9d, (%r8)
movq 0x8(%rdi), %rdi
xorl %ebx, %ebx
shrq $0x30, %rdi
jne 0x7f47
movl %r9d, %r10d
movl %r10d, (%r8)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r11d, %r11d
xorl %ebx, %ebx
xorl %eax, %eax
movl %r9d, %r10d
movl (%rsi,%r11,4), %ebp
movl %ebp, %r15d
andl $0xf, %r15d
movl %ebp, %r14d
shrl $0x4, %r14d
cmpl $0x4, %r15d
je 0x7f8f
cmpl $0x1, %r15d
je 0x7f8f
testl %r15d, %r15d
jne 0x7f9f
cmpl %edx, %r9d
jg 0x7f40
leal (%r14,%r10), %ebx
cmpl %edx, %ebx
jg 0x7fb4
addl %eax, %r14d
movl %ebx, %r10d
movl %r14d, %eax
movl %r14d, %ebx
jmp 0x7f95
addl %eax, %r14d
movl %r14d, %eax
incq %r11
cmpq %r11, %rdi
jne 0x7f51
jmp 0x7f3b
andl $0xe, %ebp
cmpl $0x2, %ebp
jne 0x7f95
addl %r10d, %r14d
cmpl %edx, %r14d
jg 0x7fbe
movl %r14d, %r10d
jmp 0x7f95
movl %edx, (%r8)
subl %r10d, %edx
addl %edx, %eax
jmp 0x7f40
testl %ecx, %ecx
cmovel %r14d, %r10d
movl %r10d, (%r8)
jmp 0x7f40
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam_view.c
// Function: view_func
static inline int __g_skip_aln(const bam_header_t *h, const bam1_t *b)
{
	if (b->core.qual < g_min_mapQ || ((b->core.flag & g_flag_on) != g_flag_on) || (b->core.flag & g_flag_off))
		return 1;
	if (g_rg) {
		uint8_t *s = bam_aux_get(b, "RG");
		if (s && strcmp(g_rg, (char*)(s + 1)) == 0) return 0;
	}
	if (g_library) {
		const char *p = bam_get_library((bam_header_t*)h, b);
		return (p && strcmp(p, g_library) == 0)? 0 : 1;
	}
	return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
cmpl 0x240b3(%rip), %ecx     # 0x2f108
jl 0xb0fe
shrq $0x20, %rax
movzwl %ax, %eax
movl %eax, %ecx
notl %ecx
testl %ecx, 0x24094(%rip)     # 0x2f100
jne 0xb0fe
testl %eax, 0x2408c(%rip)     # 0x2f104
jne 0xb0fe
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
cmpq $0x0, 0x24083(%rip)     # 0x2f118
je 0xb0c1
leaq 0x18e93(%rip), %rsi     # 0x23f31
movq %rbx, %rdi
callq 0x1175c
testq %rax, %rax
je 0xb0c1
movq 0x24066(%rip), %rdi     # 0x2f118
incq %rax
movq %rax, %rsi
callq 0x34e0
testl %eax, %eax
je 0xb0ee
cmpq $0x0, 0x24047(%rip)     # 0x2f110
je 0xb0ee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x134e4
testq %rax, %rax
je 0xb0f9
movq 0x2402e(%rip), %rsi     # 0x2f110
movq %rax, %rdi
callq 0x34e0
testl %eax, %eax
jne 0xb0f9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15157
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam_view.c
// Function: main_import
int main_import(int argc, char *argv[])
{
	int argc2, ret;
	char **argv2;
	if (argc != 4) {
		fprintf(stderr, "Usage: bamtk import <in.ref_list> <in.sam> <out.bam>\n");
		return 1;
	}
	argc2 = 6;
	argv2 = calloc(6, sizeof(char*));
	argv2[0] = "import", argv2[1] = "-o", argv2[2] = argv[3], argv2[3] = "-bt", argv2[4] = argv[1], argv2[5] = argv[2];
	ret = main_samview(argc2, argv2);
	free(argv2);
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jne 0xb171
movq %rsi, %rbx
movl $0x6, %edi
movl $0x8, %esi
callq 0x3530
movq %rax, %r14
leaq 0x18dfd(%rip), %rax     # 0x23f23
movq %rax, (%r14)
leaq 0x18dfa(%rip), %rax     # 0x23f2a
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
leaq 0x18dea(%rip), %rax     # 0x23f2d
movq %rax, 0x18(%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x20(%r14)
movl $0x6, %edi
movq %r14, %rsi
callq 0xa8fc
movl %eax, %ebx
movq %r14, %rdi
callq 0x32c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x39fb
movl $0x1, %eax
jmp 0xb169
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_rmdup.c
// Function: clear_best
static void clear_best(khash_t(lib) *aux, int max)
{
	khint_t k;
	for (k = kh_begin(aux); k != kh_end(aux); ++k) {
		if (kh_exist(aux, k)) {
			lib_aux_t *q = &kh_val(aux, k);
			if (kh_size(q->best_hash) >= max)
				kh_clear(pos, q->best_hash);
		}
	}
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
je 0xbfea
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%r14), %rcx
movl %r15d, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0xbfd7
movq 0x20(%r14), %rcx
movl %r15d, %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rcx,%rdx,8), %r12
cmpl %ebx, 0x4(%r12)
jb 0xbfd7
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0xbfd7
movl (%r12), %eax
shrl $0x4, %eax
leaq 0x4(,%rax,4), %rdx
movl $0xaa, %esi
callq 0x3060
movq $0x0, 0x4(%r12)
movl (%r14), %eax
incl %r15d
addl $0x2, %ebp
cmpl %eax, %r15d
jne 0xbf78
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_rmdup.c
// Function: clear_del_set
static void clear_del_set(khash_t(name) *del_set)
{
	khint_t k;
	for (k = kh_begin(del_set); k < kh_end(del_set); ++k)
		if (kh_exist(del_set, k))
			free((char*)kh_key(del_set, k));
	kh_clear(name, del_set);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
je 0xc043
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq %r15, %rdx
shrq $0x4, %rdx
movl (%rcx,%rdx,4), %edx
movl %r14d, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0xc029
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x32c0
movl (%rbx), %eax
incq %r15
movl %eax, %ecx
addl $0x2, %r14d
cmpq %rcx, %r15
jb 0xbfff
shrl $0x4, %eax
leal 0x4(,%rax,4), %edx
jmp 0xc048
movl $0x4, %edx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc063
movl $0xaa, %esi
callq 0x3060
movq $0x0, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq