LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/bubble.c
// Function: mag_g_pop_simple
void mag_g_pop_simple(mag_t *g, float max_cov, float max_frac, int min_merge_len, int aggressive)
{
	int64_t i, n_examined = 0, n_popped = 0;
	int ret;
	double t;

	t = cputime();
	for (i = 0; i < g->v.n; ++i) {
		ret = mag_vh_pop_simple(g, i<<1|0, max_cov, max_frac, aggressive);
		if (ret >= 1) ++n_examined;
		if (ret >= 2) ++n_popped;
		ret = mag_vh_pop_simple(g, i<<1|1, max_cov, max_frac, aggressive);
		if (ret >= 1) ++n_examined;
		if (ret >= 2) ++n_popped;
	}
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] examined %ld bubbles and popped %ld in %.3f sec\n", __func__, (long)n_examined, (long)n_popped, cputime() - t);
	mag_g_merge(g, 0, min_merge_len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdi, %rbp
callq 0x4fe7
movsd %xmm0, 0x18(%rsp)
cmpq $0x0, (%rbp)
je 0x186c0
movl $0x1, %r15d
movl %ebx, 0xc(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
xorl %r14d, %r14d
movq %rbp, 0x10(%rsp)
movq %rax, 0x20(%rsp)
leaq -0x1(%r15), %rsi
movq %rbp, %rdi
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movl 0xc(%rsp), %r12d
movl %r12d, %edx
callq 0x18113
xorl %r13d, %r13d
testl %eax, %eax
setg %r13b
xorl %ebp, %ebp
cmpl $0x2, %eax
setge %bpl
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movl %r12d, %edx
callq 0x18113
xorl %r12d, %r12d
testl %eax, %eax
setg %r12b
addq %r14, %r12
addq %r13, %r12
xorl %r13d, %r13d
cmpl $0x2, %eax
setge %r13b
addq 0x20(%rsp), %r13
addq %rbp, %r13
movq 0x10(%rsp), %rbp
incq %rbx
addq $0x2, %r15
movq %r13, %rax
movq %r12, %r14
cmpq (%rbp), %rbx
jb 0x18630
jmp 0x186c6
xorl %r12d, %r12d
xorl %r13d, %r13d
leaq 0xcb93(%rip), %rax      # 0x25260
cmpl $0x3, (%rax)
jge 0x186ee
movq %rbp, %rdi
xorl %esi, %esi
movl 0x8(%rsp), %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12031
movq 0xc903(%rip), %rax      # 0x24ff8
movq (%rax), %r15
callq 0x4fe7
subsd 0x18(%rsp), %xmm0
leaq 0x6686(%rip), %rsi      # 0x1ed90
leaq 0x66b8(%rip), %rdx      # 0x1edc9
movq %r15, %rdi
movq %r12, %rcx
movq %r13, %r8
movb $0x1, %al
callq 0x21c0
jmp 0x186d2
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/bubble.c
// Function: mag_g_pop_open
void mag_g_pop_open(mag_t *g, int min_elen)
{
	int64_t i;
	double t;
	t = cputime();
	for (i = 0; i < g->v.n; ++i)
		mag_v_pop_open(g, &g->v.a[i], min_elen);
	if (fm_verbose >= 3)
		fprintf(stderr, "[M:%s] popped open bubbles in %.3f sec\n", __func__, cputime() - t);
	mag_g_merge(g, 0, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4fe7
movsd %xmm0, (%rsp)
cmpq $0x0, (%rbx)
je 0x18bce
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x18723
incq %r15
addq $0x68, %r14
cmpq (%rbx), %r15
jb 0x18bb1
leaq 0xc68b(%rip), %rax      # 0x25260
cmpl $0x3, (%rax)
jge 0x18bf0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12031
movsd (%rsp), %xmm0
callq 0x2f1c
jmp 0x18bda
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: fm_sa_gen
fmsa_t *fm_sa_gen(const rld_t *e, int ssa_shift, int n_threads)
{
	extern void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n);
	fmsa_t *sa;
	worker_t *w;
	int i;

	sa = calloc(1, sizeof(fmsa_t));
	sa->ss = ssa_shift;
	sa->m = e->mcnt[1];
	for (sa->ms = 1; 1LL<<sa->ms < sa->m; ++sa->ms);
	sa->n_ssa = (e->mcnt[0] - e->mcnt[1] + (1<<sa->ss) - 1) >> sa->ss;
	sa->r2i = calloc(sa->m, 8);
	sa->ssa = calloc(sa->n_ssa, 8);

	w = calloc(1, sizeof(worker_t));
	w->buf = calloc(n_threads, sizeof(uint64_v));
	w->sa = sa;
	w->e = e;

	kt_for(n_threads, worker, w, sa->m);

	for (i = 0; i < n_threads; ++i) free(w->buf[i].a);
	free(w->buf); free(w);
	return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x2190
movq %rax, %rbx
movl %r12d, 0x4(%rax)
movq 0x28(%r14), %rdx
movq 0x8(%rdx), %r15
movq %r15, 0x8(%rax)
xorl %eax, %eax
incq %rax
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
cmpq %r15, %rsi
jl 0x18c33
movl $0x1, %esi
movl %r12d, %ecx
shll %cl, %esi
movl %eax, (%rbx)
movslq %esi, %rax
addq (%rdx), %rax
movq %r15, %r13
notq %r13
addq %rax, %r13
shrq %cl, %r13
movq %r13, 0x10(%rbx)
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rax, 0x18(%rbx)
movl $0x8, %esi
movq %r13, %rdi
callq 0x2190
movq %rax, 0x20(%rbx)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2190
movq %rax, %r12
movslq %ebp, %r13
movl $0x18, %esi
movq %r13, %rdi
callq 0x2190
movq %rax, 0x10(%r12)
movq %rbx, 0x8(%r12)
movq %r14, (%r12)
leaq 0x5c(%rip), %rsi        # 0x18d1c
movl %r13d, %edi
movq %r12, %rdx
movq %r15, %rcx
callq 0x340c
testl %r13d, %r13d
jle 0x18cf8
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r14
xorl %r15d, %r15d
movq 0x10(%r12), %rax
movq 0x10(%rax,%r15), %rdi
callq 0x2040
addq $0x18, %r15
cmpq %r15, %r14
jne 0x18ce0
movq 0x10(%r12), %rdi
callq 0x2040
movq %r12, %rdi
callq 0x2040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: fm_sa
int64_t fm_sa(const rld_t *e, const fmsa_t *sa, int64_t k, int64_t *si)
{
	int c, mask = (1<<sa->ss) - 1;
	int64_t x = 0;
	uint64_t ok[e->asize1];
	*si = -1;
	if (k >= e->mcnt[0]) return -1;
	while (k < e->mcnt[1] || ((k - e->mcnt[1]) & mask)) {
		++x;
		c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) {
			*si = sa->r2i[k];
			return x - 1;
		}
	}
	k = (k - e->mcnt[1]) >> sa->ss;
	*si = sa->ssa[k] & ((1ULL<<sa->ms) - 1);
	return x + (sa->ssa[k] >> sa->ms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r8
movl 0x4(%rsi), %ecx
movzbl 0x1(%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
movq $-0x1, (%r8)
movq 0x28(%rdi), %rax
movq $-0x1, %r15
cmpq %rdx, (%rax)
jbe 0x18e43
movq %rsi, %r14
movq %rdi, %r12
movq %r8, -0x30(%rbp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
shll %cl, %ebx
notl %ebx
xorl %r15d, %r15d
movq 0x28(%r12), %rax
movq %rdx, %rsi
subq 0x8(%rax), %rsi
jb 0x18dcd
testl %ebx, %esi
je 0x18e0f
incq %r15
incq %rdx
movq %r12, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x4895
movq 0x20(%r12), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movq (%r13,%rax,8), %rdx
addq %rcx, %rdx
decq %rdx
testl %eax, %eax
jne 0x18dbb
movq 0x18(%r14), %rax
movq (%rax,%rdx,8), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
decq %r15
jmp 0x18e43
movb (%r14), %al
movb 0x4(%r14), %cl
shrq %cl, %rsi
movq $-0x1, %rdx
movl %eax, %ecx
shlq %cl, %rdx
movq 0x20(%r14), %rcx
notq %rdx
andq (%rcx,%rsi,8), %rdx
movq -0x30(%rbp), %rdi
movq %rdx, (%rdi)
movq (%rcx,%rsi,8), %rdx
movl %eax, %ecx
shrq %cl, %rdx
addq %rdx, %r15
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: fm_sa_dump
int fm_sa_dump(const fmsa_t *sa, const char *fn)
{
	uint32_t y;
	FILE *fp;
	fp = fn && strcmp(fn, "-")? fopen(fn, "wb") : fdopen(fileno(stdout), "wb");
	if (fp == 0) return -1;
	y = sa->ss; fwrite(&y, 4, 1, fp);
	y = sa->ms; fwrite(&y, 4, 1, fp);
	fwrite(&sa->m, 8, 1, fp);
	fwrite(&sa->n_ssa, 8, 1, fp);
	fwrite(sa->r2i, 8, sa->m, fp);
	fwrite(sa->ssa, 8, sa->n_ssa, fp);
	fclose(fp);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x18e85
cmpb $0x2d, (%rsi)
jne 0x18e71
cmpb $0x0, 0x1(%rsi)
je 0x18e85
leaq 0x4211(%rip), %rax      # 0x1d089
movq %rsi, %rdi
movq %rax, %rsi
callq 0x22d0
jmp 0x18ea2
movq 0xc134(%rip), %rax      # 0x24fc0
movq (%rax), %rdi
callq 0x2200
leaq 0x41ee(%rip), %rsi      # 0x1d089
movl %eax, %edi
callq 0x2270
movq %rax, %r14
testq %rax, %rax
je 0x18f4a
movl 0x4(%rbx), %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2310
movl (%rbx), %eax
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2310
leaq 0x8(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2310
leaq 0x10(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2310
movq 0x8(%rbx), %rdx
movq 0x18(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x2310
movq 0x10(%rbx), %rdx
movq 0x20(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x2310
movq %r14, %rdi
callq 0x20d0
xorl %eax, %eax
jmp 0x18f4f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: fm_sa_restore
fmsa_t *fm_sa_restore(const char *fn)
{
	FILE *fp;
	uint32_t y;
	fmsa_t *sa;
	fp = fn && strcmp(fn, "-")? fopen(fn, "rb") : fdopen(fileno(stdin), "rb");
	if (fp == 0) return 0;
	sa = calloc(1, sizeof(fmsa_t));
	fread(&y, 4, 1, fp); sa->ss = y;
	fread(&y, 4, 1, fp); sa->ms = y;
	fread(&sa->m, 8, 1, fp);
	fread(&sa->n_ssa, 8, 1, fp);
	sa->r2i = calloc(sa->m, 8);
	sa->ssa = calloc(sa->n_ssa, 8);
	if (sa->ssa == 0 || sa->r2i == 0) {
		free(sa->r2i); free(sa->ssa); free(sa);
		return 0;
	}
	fread(sa->r2i, 8, sa->m, fp);
	fread(sa->ssa, 8, sa->n_ssa, fp);
	fclose(fp);
	return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18f82
cmpb $0x2d, (%rdi)
jne 0x18f74
cmpb $0x0, 0x1(%rdi)
je 0x18f82
leaq 0x4116(%rip), %rsi      # 0x1d091
callq 0x22d0
jmp 0x18f9f
movq 0xc03f(%rip), %rax      # 0x24fc8
movq (%rax), %rdi
callq 0x2200
leaq 0x40f9(%rip), %rsi      # 0x1d091
movl %eax, %edi
callq 0x2270
movq %rax, %r14
testq %rax, %rax
je 0x1907b
movl $0x1, %edi
movl $0x28, %esi
callq 0x2190
movq %rax, %rbx
leaq 0x4(%rsp), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2090
movl (%r15), %eax
movl %eax, 0x4(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2090
movl (%r15), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2090
leaq 0x10(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2090
movq 0x8(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rax, %rbp
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x2190
movq %rax, %r13
movq %rax, 0x20(%rbx)
testq %rax, %rax
setne %al
testq %rbp, %rbp
setne %cl
testb %al, %cl
jne 0x1907f
movq %rbp, %rdi
callq 0x2040
movq %r13, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
jmp 0x190ad
movl $0x8, %esi
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2090
movl $0x8, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2090
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: main_sa
int main_sa(int argc, char *argv[])
{
	int c, n_threads = 1, ssa_shift = 6;
	fmsa_t *sa;
	rld_t *e;
	char *fn = 0;

	while ((c = getopt(argc, argv, "t:s:o:")) >= 0) {
		if (c == 't') n_threads = atoi(optarg);
		else if (c == 's') ssa_shift = atoi(optarg);
		else if (c == 'o') fn = optarg;
	}
	if (argc == optind) {
		fprintf(stderr, "Usage: fermi2 sa [-t nThreads=%d] [-s stepShift=%d] <in.fmd>\n", n_threads, ssa_shift);
		return 1;
	}
	e = rld_restore(argv[optind]);
	if (e == 0) {
		fprintf(stderr, "[E::%s] failed to load the FM-index\n", __func__);
		return 1;
	}
	sa = fm_sa_gen(e, ssa_shift, n_threads);
	//{int64_t i;for (i = 0; i < sa->n_ssa; ++i) fprintf(stderr, "S(%lld)=%lld\n", (i<<sa->ss) + e->mcnt[1], sa->ssa[i]>>sa->ms);}

	fm_sa_dump(sa, fn);
	rld_destroy(e);
	fm_sa_destroy(sa);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r12d
leaq 0x5d3a(%rip), %rdx      # 0x1ee11
callq 0x22f0
testl %eax, %eax
js 0x19142
movl $0x6, %ebx
movl $0x1, %ebp
movq $0x0, (%rsp)
movq 0xbedf(%rip), %r15      # 0x24fd8
leaq 0x5d11(%rip), %r13      # 0x1ee11
cmpl $0x6f, %eax
je 0x19127
cmpl $0x73, %eax
je 0x1911b
cmpl $0x74, %eax
jne 0x1912e
movq (%r15), %rdi
callq 0x2300
movl %eax, %ebp
jmp 0x1912e
movq (%r15), %rdi
callq 0x2300
movl %eax, %ebx
jmp 0x1912e
movq (%r15), %rax
movq %rax, (%rsp)
movl %r12d, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x19100
jmp 0x19154
movl $0x1, %ebp
movl $0x6, %ebx
movq $0x0, (%rsp)
movq 0xbe75(%rip), %rax      # 0x24fd0
movslq (%rax), %rax
cmpl %r12d, %eax
je 0x191b0
movq (%r14,%rax,8), %rdi
callq 0x4119
testq %rax, %rax
je 0x191ce
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x18bfc
movq %rax, %rbx
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x18e55
movq %r14, %rdi
callq 0x36d4
movq %rbx, %rdi
callq 0x18d40
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbe41(%rip), %rax      # 0x24ff8
movq (%rax), %rdi
leaq 0x5c57(%rip), %rsi      # 0x1ee18
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x21c0
jmp 0x191d3
callq 0x2f59
movl $0x1, %eax
jmp 0x191a1
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sa.c
// Function: sa_gen1
static void sa_gen1(const rld_t *e, fmsa_t *sa, int64_t k, uint64_v *buf)
{
	int c, mask = (1<<sa->ss) - 1;
	uint64_t ok[e->asize1], k0 = k, l = 0;
	size_t i;
	buf->n = 0;
	do {
		++l;
		c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c) {
			if (((k - e->mcnt[1]) & mask) == 0) {
				int64_t x = (k - e->mcnt[1]) >> sa->ss;
				sa->ssa[x] = l;
				kv_push(uint64_t, *buf, x);
			}
		} else sa->r2i[k] = k0;
	} while (c);
	for (i = 0; i < buf->n; ++i)
		sa->ssa[buf->a[i]] = (l - 1 - sa->ssa[buf->a[i]]) << sa->ms | k0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r8
movq %rsi, -0x38(%rbp)
movb 0x4(%rsi), %cl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
shll %cl, %r14d
movq %rdi, %r12
movzbl 0x1(%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
movq %r8, -0x30(%rbp)
movq $0x0, (%r8)
movq %rdx, -0x40(%rbp)
leaq 0x1(%rdx), %rsi
movq %r13, %rdx
callq 0x4895
movq 0x20(%r12), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rax
movq (%r13,%rdx,8), %r15
leaq (%r15,%rax), %rbx
decq %rbx
testl %edx, %edx
je 0x192fd
notl %r14d
movq %r14, -0x48(%rbp)
addq %rax, %r15
xorl %r14d, %r14d
incq %r14
movq 0x28(%r12), %rax
subq 0x8(%rax), %rbx
testl %ebx, -0x48(%rbp)
jne 0x192ca
movq -0x38(%rbp), %rax
movb 0x4(%rax), %cl
shrq %cl, %rbx
movq 0x20(%rax), %rax
movq %r14, (%rax,%rbx,8)
movq -0x30(%rbp), %rdi
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rcx
jne 0x192bf
leaq (%rcx,%rcx), %rsi
testq %rcx, %rcx
movl $0x2, %ecx
cmoveq %rcx, %rsi
movq %rsi, 0x8(%rdi)
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x2260
movq -0x30(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq (%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rdi)
movq %rbx, (%rax,%rcx,8)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4895
movq 0x20(%r12), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movq (%r13,%rax,8), %rdx
leaq (%rdx,%rcx), %r15
leaq (%rdx,%rcx), %rbx
decq %rbx
testl %eax, %eax
jne 0x19260
jmp 0x19300
xorl %r14d, %r14d
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
movq -0x40(%rbp), %r10
movq %r10, (%rax,%rbx,8)
movq -0x30(%rbp), %r9
cmpq $0x0, (%r9)
je 0x19343
movq 0x20(%rcx), %rax
movq 0x10(%r9), %rdx
movl (%rcx), %ecx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq %r14, %r8
subq (%rax,%rdi,8), %r8
shlq %cl, %r8
orq %r10, %r8
movq %r8, (%rax,%rdi,8)
incq %rsi
cmpq (%r9), %rsi
jb 0x19326
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/match.c
// Function: fm_exact
void fm_exact(const rld_t *e, const char *s, int64_t *_l, int64_t *_u)
{
	extern unsigned char seq_nt6_table[128];
	int64_t i, l = 0, u = e->mcnt[0];
	for (i = strlen(s) - 1; i >= 0; --i) {
		int c = (uint8_t)s[i];
		c = c < 6? c : c < 128? seq_nt6_table[c] : 5;
		l = e->cnt[c] + rld_rank11(e, l, c);
		u = e->cnt[c] + rld_rank11(e, u, c);
		if (l >= u) break;
	}
	*_l = l, *_u = u;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rdi, 0x10(%rsp)
movq 0x28(%rdi), %rax
movq (%rax), %r15
movq %rsi, 0x18(%rsp)
movq %rsi, %rdi
callq 0x20e0
movq %rax, %rbx
decq %rbx
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
testq %rbx, %rbx
js 0x19ab9
movq 0x18(%rsp), %rax
movzbl (%rax,%rbx), %eax
cmpq $0x6, %rax
jb 0x19a66
testb %al, %al
js 0x19a64
leaq 0xb781(%rip), %rcx      # 0x251e0
movb (%rcx,%rax), %al
jmp 0x19a66
movb $0x5, %al
movzbl %al, %r14d
movq 0x20(%r13), %rax
leal (,%r14,8), %r12d
movq (%rax,%r12), %rax
movq %rax, 0x20(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movl %r14d, %edx
callq 0x4854
movq %rax, %rbp
addq 0x20(%rsp), %rbp
movq 0x20(%r13), %rax
movq (%rax,%r12), %r12
movq %r13, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x4854
movq %rax, %r15
addq %r12, %r15
decq %rbx
cmpq %r15, %rbp
jl 0x19a40
movq (%rsp), %rax
movq %rbp, (%rax)
movq 0x8(%rsp), %rax
movq %r15, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/profk.c
// Function: fm_extend_to
int fm_extend_to(const rld_t *e, const char *s, int x, int min_ext, int sat_occ, int *occ)
{
	extern unsigned char seq_nt6_table[128];
	int i, k;
	uint64_t l = 0, u = e->mcnt[0];
	*occ = 0;
	if (x + 1 - min_ext < 0) return 0;
	for (i = x, k = 0; i >= 0; --i) {
		int c = (uint8_t)s[i];
		uint64_t l0 = l, u0 = u;
		c = c < 6? c : c < 128? seq_nt6_table[c] : 5;
		l = e->cnt[c] + rld_rank11(e, l, c);
		u = e->cnt[c] + rld_rank11(e, u, c);
		if (l >= u) break; // can't be extended
		++k;
		if (sat_occ > 0) {
			if (k > min_ext && u - l < sat_occ) {
				--k, l = l0, u = u0;
				break;
			}
		} else if (k == min_ext) {
			break;
		}
	}
	if (l < u) *occ = u - l;
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, 0x14(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x28(%rdi), %rax
movq (%rax), %r12
movq %r9, 0x28(%rsp)
movl $0x0, (%r9)
leal 0x1(%rdx), %eax
xorl %esi, %esi
movl %ecx, 0x10(%rsp)
cmpl %ecx, %eax
jl 0x1b236
testl %edx, %edx
js 0x1b201
movl 0x14(%rsp), %eax
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
movl $0x1, %edi
xorl %esi, %esi
movq 0x38(%rsp), %r13
movl %edx, %eax
movq 0x40(%rsp), %rcx
movzbl (%rcx,%rax), %eax
cmpq $0x6, %rax
movq %rdx, 0x18(%rsp)
movq %rsi, 0x48(%rsp)
movq %r12, 0x50(%rsp)
jb 0x1b156
testb %al, %al
js 0x1b154
leaq 0xa091(%rip), %rcx      # 0x251e0
movb (%rcx,%rax), %al
jmp 0x1b156
movb $0x5, %al
movq %rdi, 0x20(%rsp)
leal -0x1(%rdi), %r15d
movzbl %al, %r14d
movq 0x20(%r13), %rax
leal (,%r14,8), %ebx
movq (%rax,%rbx), %r12
movq %r13, %rdi
movq %rbp, 0x8(%rsp)
movq %rbp, %rsi
movl %r14d, %edx
callq 0x4854
movq %rax, %rbp
addq %r12, %rbp
movq 0x20(%r13), %rax
movq (%rax,%rbx), %rbx
movq %r13, %rdi
movq 0x50(%rsp), %r12
movq %r12, %rsi
movl %r14d, %edx
callq 0x4854
addq %rbx, %rax
movq %rax, %rdx
subq %rbp, %rdx
jbe 0x1b20e
movq 0x48(%rsp), %rsi
leal 0x1(%rsi), %ecx
cmpl $0x0, 0x14(%rsp)
jle 0x1b1df
cmpl 0x10(%rsp), %r15d
jl 0x1b1cf
cmpq 0x30(%rsp), %rdx
jb 0x1b221
movq 0x18(%rsp), %rdx
testl %edx, %edx
movq 0x20(%rsp), %rdi
jg 0x1b1f3
jmp 0x1b213
movq 0x20(%rsp), %rdi
cmpl %edi, 0x10(%rsp)
je 0x1b217
movq 0x18(%rsp), %rdx
testl %edx, %edx
jle 0x1b217
decl %edx
incl %edi
movq %rax, %r12
movl %ecx, %esi
jmp 0x1b124
xorl %esi, %esi
movq $0x0, 0x8(%rsp)
jmp 0x1b221
movl %r15d, %esi
jmp 0x1b219
movl %ecx, %esi
jmp 0x1b219
movl %edi, %esi
movq %rbp, 0x8(%rsp)
movq %rax, %r12
movq 0x8(%rsp), %rax
cmpq %rax, %r12
jbe 0x1b236
subl %eax, %r12d
movq 0x28(%rsp), %rax
movl %r12d, (%rax)
movl %esi, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/profk.c
// Function: fm_kprof
fm_icnt_t *fm_kprof(const rld_t *e, const char *s, int min_ext, int sat_occ, int *n_)
{
	int i, x, len, k = 0;
	fm_icnt_t *a;
	len = strlen(s);
	MALLOC(a, len);
	for (x = len - 1; x >= min_ext - 1;) {
		int y, occ;
		y = fm_extend_to(e, s, x, min_ext, sat_occ, &occ);
		a[k].st = x + 1 - (y >= min_ext? y : min_ext);
		a[k].en = x + 1;
		a[k++].occ = occ;
		x -= (y >= min_ext? y - min_ext : 0) + 1;
	}
	*n_ = k;
	for (i = 0; i < k>>1; ++i) {
		fm_icnt_t t = a[i];
		a[i] = a[k - i - 1]; a[k - i - 1] = t;
	}
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movq %rsi, %rdi
callq 0x20e0
movq %rax, %r14
movslq %r14d, %rbx
leaq (,%rbx,4), %rax
leaq (%rax,%rax,2), %rdi
callq 0x2220
movq %rax, %r12
cmpl %r15d, %ebx
jge 0x1b29b
movl $0x0, (%r13)
jmp 0x1b385
movq %r13, 0x20(%rsp)
leal -0x1(%r15), %eax
movl %eax, 0x1c(%rsp)
decl %r14d
movq %r12, %rbx
addq $0x8, %rbx
movl %ebp, 0x18(%rsp)
xorl %ebp, %ebp
movq 0x28(%rsp), %r13
movq %r13, %rdi
movq 0x30(%rsp), %rsi
movl %r14d, %edx
movl %r15d, %ecx
movl 0x18(%rsp), %r8d
leaq 0x8(%rsp), %r9
callq 0x1b0c4
movl %eax, %ecx
notl %ecx
addl %r15d, %ecx
cmpl %r15d, %eax
cmovlel %r15d, %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovll %edx, %ecx
leal 0x1(%r14), %edx
negl %eax
addl %r14d, %eax
incl %eax
movl %eax, -0x8(%rbx)
movl %edx, -0x4(%rbx)
movl 0x8(%rsp), %eax
incq %rbp
movl %eax, (%rbx)
addl %r14d, %ecx
addq $0xc, %rbx
movl %ecx, %r14d
cmpl 0x1c(%rsp), %ecx
jge 0x1b2bd
movq 0x20(%rsp), %rax
movl %ebp, (%rax)
cmpq $0x1, %rbp
je 0x1b385
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rax
leaq -0xc(,%rax,4), %rax
shrl %ecx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movl 0x8(%r12,%rdx), %esi
movl %esi, 0x10(%rsp)
movq (%r12,%rdx), %rsi
movq %rsi, 0x8(%rsp)
movl 0x8(%r12,%rax), %esi
movl %esi, 0x8(%r12,%rdx)
movq (%r12,%rax), %rsi
movq %rsi, (%r12,%rdx)
movl 0x10(%rsp), %esi
movl %esi, 0x8(%r12,%rax)
movq 0x8(%rsp), %rsi
movq %rsi, (%r12,%rax)
addq $0xc, %rdx
addq $-0xc, %rax
cmpq %rdx, %rcx
jne 0x1b342
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/algodesigner[P]z80/z80.c
// Function: z80_new
z80 *z80_new() {
    _console_init();
    z80 *cpu = calloc(1, sizeof(z80));
    z80_reset(cpu);
    return cpu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x91bc
movl $0x1, %edi
movl $0x10060, %esi          # imm = 0x10060
callq 0x9060
movq $-0x1, 0x44(%rax)
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/algodesigner[P]z80/z80.c
// Function: watchprint
void watchprint(z80 *cpu, uint16_t pos) {
    uint8_t I, J;
    _puts("\r\n");
    _puts("  Watch : "); _puthex16(cpu->watch);
    _puts(" = "); _puthex8(_RamRead(cpu->watch)); _putcon(':'); _puthex8(_RamRead(cpu->watch + 1));
    _puts(" / ");
    for (J = 0, I = _RamRead(cpu->watch); J < 8; ++J, I <<= 1) _putcon(I & 0x80 ? '1' : '0');
    _putcon(':');
    for (J = 0, I = _RamRead(cpu->watch + 1); J < 8; ++J, I <<= 1) _putcon(I & 0x80 ? '1' : '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x84a2(%rip), %rdi      # 0x11840
callq 0x927a
leaq 0x8366(%rip), %rdi      # 0x11710
callq 0x927a
movzwl 0x4c(%rbx), %edi
callq 0x92ff
leaq 0x835c(%rip), %rdi      # 0x1171b
callq 0x927a
movslq 0x4c(%rbx), %rax
movzbl 0x60(%rbx,%rax), %edi
callq 0x92aa
movl $0x3a, %edi
callq 0x9267
movslq 0x4c(%rbx), %rax
movzbl 0x61(%rax,%rbx), %edi
callq 0x92aa
leaq 0x832e(%rip), %rdi      # 0x1171f
callq 0x927a
movslq 0x4c(%rbx), %rax
movb 0x60(%rbx,%rax), %r14b
movb $0x8, %r15b
xorl %edi, %edi
testb %r14b, %r14b
setns %dil
xorl $0x31, %edi
callq 0x9267
addb %r14b, %r14b
decb %r15b
jne 0x9402
movl $0x3a, %edi
callq 0x9267
movslq 0x4c(%rbx), %rax
movb 0x61(%rbx,%rax), %bl
movb $0x8, %r14b
xorl %edi, %edi
testb %bl, %bl
setns %dil
xorl $0x31, %edi
callq 0x9267
addb %bl, %bl
decb %r14b
jne 0x9430
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/algodesigner[P]z80/z80.c
// Function: memdump
void memdump(z80 *cpu, uint16_t pos) {
    uint16_t h = pos;
    uint16_t c = pos;
    uint8_t l, i;
    uint8_t ch = pos & 0xff;

    _puts("       ");
    for (i = 0; i < 16; ++i) {
        _puthex8(ch++ & 0x0f);
        _puts(" ");
    }
    _puts("\r\n");
    _puts("       ");
    for (i = 0; i < 16; ++i)
        _puts("---");
    _puts("\r\n");
    for (l = 0; l < 16; ++l) {
        _puthex16(h);
        _puts(" : ");
        for (i = 0; i < 16; ++i) {
            _puthex8(_RamRead(h++));
            _puts(" ");
        }
        for (i = 0; i < 16; ++i) {
            ch = _RamRead(c++);
            _putcon(ch > 31 && ch < 127 ? ch : '.');
        }
        _puts("\r\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x82b7(%rip), %rdi      # 0x11723
callq 0x927a
xorl %r12d, %r12d
leaq 0x82ae(%rip), %r15      # 0x11729
leal (%rbx,%r12), %eax
andb $0xf, %al
movzbl %al, %edi
callq 0x92aa
movq %r15, %rdi
callq 0x927a
incb %r12b
cmpb $0x10, %r12b
jne 0x947b
leaq 0x839f(%rip), %rdi      # 0x11840
callq 0x927a
leaq 0x8276(%rip), %rdi      # 0x11723
callq 0x927a
movb $0x10, %r12b
leaq 0x826f(%rip), %r15      # 0x1172b
movq %r15, %rdi
callq 0x927a
decb %r12b
jne 0x94bc
leaq 0x8370(%rip), %rdi      # 0x11840
callq 0x927a
xorl %eax, %eax
leaq 0x824b(%rip), %r13      # 0x11729
movl %ebx, %r12d
movl %eax, -0x30(%rbp)
movl %r12d, -0x2c(%rbp)
movzwl %r12w, %r15d
movl %r15d, %edi
callq 0x92ff
leaq 0x8283(%rip), %rdi      # 0x1177e
callq 0x927a
xorl %r12d, %r12d
leal (%r15,%r12), %eax
movzwl %ax, %eax
movzbl 0x60(%r14,%rax), %edi
callq 0x92aa
movq %r13, %rdi
callq 0x927a
incl %r12d
cmpb $0x10, %r12b
jne 0x9503
movl -0x2c(%rbp), %eax
addl %r12d, %eax
movl %eax, %r12d
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
movzwl %ax, %eax
movzbl 0x60(%r14,%rax), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x954c
movl $0x2e, %eax
movzbl %al, %edi
callq 0x9267
incl %r15d
cmpb $0x10, %r15b
jne 0x9532
leaq 0x82dc(%rip), %rdi      # 0x11840
callq 0x927a
movl -0x30(%rbp), %eax
incb %al
addl %r15d, %ebx
cmpb $0x10, %al
jne 0x94e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/algodesigner[P]z80/main.c
// Function: main
int main(int argc, char *argv[])
{
    /*
     * Instantiate the CPU, activate the debug mode, set the intercept
     * function and run the virtual CPU until the termination criteria
     * set by the intercept function, if any, are met.
     */
    z80 *cpu = z80_new();
    cpu->debug = 1;
    z80_set_intercept(cpu, cpu, intercept);
    z80_run(cpu);
    z80_destroy(cpu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x9330
movq %rax, %rbx
movl $0x1, 0x40(%rax)
leaq 0x24(%rip), %rdx        # 0xdca6
movq %rax, %rdi
movq %rax, %rsi
callq 0x937c
movq %rbx, %rdi
callq 0x9c3e
movq %rbx, %rdi
callq 0xdc55
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pyk[P]simple-nn/deps/pcg/sample/pcg32x2-demo.c
// Function: pcg32x2_boundedrand_r
uint64_t pcg32x2_boundedrand_r(pcg32x2_random_t* rng, uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg32x2_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x1202
cmpq %r15, %rax
jb 0x12c2
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/darray.c
// Function: darray_add_uniq
int 
darray_add_uniq(darray_t* da, uintptr_t elem)
{
  if (darray_exists(da, elem))
    {
      return 0;
    }
  darray_add(da, elem);
  return 1;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2813
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq %rsi, (%rdx)
je 0x281b
pushq $0x1
popq %r9
movq %r9, %r8
cmpq %r9, %rcx
je 0x280e
leaq 0x1(%r8), %r9
cmpq %rsi, (%rdx,%r8,8)
jne 0x27fc
cmpq %r8, %rcx
ja 0x281b
callq 0x6715
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/darray.c
// Function: darray_exists
inline int			
darray_exists(darray_t* da, uintptr_t elem)
{
  for (int i = 0; i < da->n_elems; i++)
    {
      if (unlikely(elem == da->array[i]))
	{
	  return 1;
	}
    }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x284c
movq 0x10(%rdi), %rax
cmpq %rsi, (%rax)
je 0x284f
pushq $0x1
popq %rdi
movq %rdi, %rdx
cmpq %rdi, %rcx
je 0x2843
leaq 0x1(%rdx), %rdi
cmpq %rsi, (%rax,%rdx,8)
jne 0x2831
xorl %eax, %eax
cmpq %rdx, %rcx
seta %al
retq
xorl %eax, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/darray.c
// Function: darray_pop
int
darray_pop(darray_t* da, uintptr_t* elem)
{
  if (unlikely(da->n_elems == 0))
    {
      return 0;
    }

  *elem = da->array[0];
  da->n_elems--;
  for (int i = 0; i < da->n_elems; i++)
    {
      da->array[i] = da->array[i + 1];
    }
  return 1;
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x2883
movq 0x10(%rdi), %rcx
movq (%rcx), %rax
movq %rax, (%rsi)
decq (%rdi)
pushq $0x1
popq %rax
je 0x2882
xorl %edx, %edx
movq 0x8(%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, (%rdi)
ja 0x286d
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_id_get_hwc_gs
hwc_gs_t*
mctop_id_get_hwc_gs(mctop_t* topo, const uint id)
{
  uint lvl = mctop_id_get_lvl(id);
  if (lvl > topo->n_levels)
    {
      return NULL;
    }
  hwc_gs_t* gs = NULL;
  if (lvl == 0)
    {
      gs = (hwc_gs_t*) &topo->hwcs[id];
    }
  else if (lvl == topo->socket_level)
    {
      gs = (hwc_gs_t*) &topo->sockets[mctop_id_no_lvl(id)];
    }
  else
    {
      hwc_gs_t* _gs = mctop_get_first_gs_at_lvl(topo, lvl);
      while (_gs != NULL)
	{
	  if (unlikely(_gs->id == id))
	    {
	      gs = _gs;
	      break;
	    }
	  _gs = _gs->next;
	}
    }

  return gs;
}

// Assembly:
movl $0x2710, %ecx           # imm = 0x2710
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
xorl %eax, %eax
cmpl (%rdi), %ecx
jbe 0x28bd
retq
cmpl $0x270f, %esi           # imm = 0x270F
ja 0x28d0
movl %esi, %eax
imulq $0x30, %rax, %rax
addq 0x40(%rdi), %rax
retq
movq 0x20(%rdi), %rax
cmpl 0x14(%rdi), %ecx
jne 0x28e6
movl %edx, %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
retq
testq %rax, %rax
je 0x2906
cmpl %ecx, 0x4(%rax)
je 0x28f9
movq 0x40(%rax), %rax
movq (%rax), %rax
jmp 0x28e6
cmpl %esi, (%rax)
je 0x28bc
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x28f9
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_ids_get_latency
uint
mctop_ids_get_latency(mctop_t* topo, const uint id0, const uint id1)
{
  hwc_gs_t* gs0 = mctop_id_get_hwc_gs(topo, id0);
  hwc_gs_t* gs1 = mctop_id_get_hwc_gs(topo, id1);
  if (gs0 == NULL || gs1 == NULL)
    {
      return 0;
    }

  while (gs0->level < gs1->level)
    {
      gs0 = gs0->parent;
    }
  while (gs1->level < gs0->level)
    {
      gs1 = gs1->parent;
    }

  if (unlikely(gs0->id == gs1->id))
    {
      if (gs0->level == 0)
	{
	  return 0;
	}
      else
	{
	  return gs0->latency;
	}
    }

  while (gs0->type != SOCKET && gs1->type != SOCKET)
    {
      gs0 = gs0->parent;
      gs1 = gs1->parent;
      if (gs0->id == gs1->id)
	{
	  return gs0->latency;
	}
    }


  sibling_t* sibling = mctop_get_sibling_with_sockets(topo, gs0, gs1);
  return sibling->latency;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
callq 0x28a9
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x28a9
testq %rbx, %rbx
sete %dl
testq %rax, %rax
sete %sil
xorl %ecx, %ecx
orb %dl, %sil
jne 0x298b
movl 0x4(%rax), %esi
movl 0x4(%rbx), %edx
cmpl %esi, %edx
jae 0x2948
movq 0x18(%rbx), %rbx
jmp 0x293b
cmpl %edx, %esi
jae 0x2955
movq 0x18(%rax), %rax
cmpl %edx, 0x4(%rax)
jb 0x294c
movl (%rbx), %esi
cmpl (%rax), %esi
je 0x2992
cmpl $0x3, 0x8(%rbx)
je 0x297a
cmpl $0x3, 0x8(%rax)
je 0x297a
movq 0x18(%rbx), %rbx
movq 0x18(%rax), %rax
movl (%rbx), %ecx
cmpl (%rax), %ecx
jne 0x295b
movl 0xc(%rbx), %ecx
jmp 0x298b
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8c06
movl 0x8(%rax), %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
testl %edx, %edx
jne 0x2975
jmp 0x298b
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_set_cpu
int
mctop_set_cpu(mctop_t* topo, int cpu) 
{
  int ret = 1;
#if defined(__sparc__)
  if (processor_bind(P_LWPID, P_MYID, cpu, NULL) == -1)
    {
      /* printf("Problem with setting processor affinity: %s\n", */
      /* 	     strerror(errno)); */
      ret = 0;
    }
#elif defined(__tile__)
  if (tmc_cpus_set_my_cpu(tmc_cpus_find_nth_cpu(&cpus, cpu)) < 0)
    {
      tmc_task_die("Failure in 'tmc_cpus_set_my_cpu()'.");
    }

  if (cpu != tmc_cpus_get_my_cpu())
    {
      PRINT("******* i am not CPU %d", tmc_cpus_get_my_cpu());
    }

#else
  cpu_set_t mask;
  CPU_ZERO(&mask);
  CPU_SET(cpu, &mask);
  if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) != 0)
    {
      /* printf("Problem with setting processor affinity: %s\n", */
      /* 	     strerror(errno)); */
      ret = 0;
    }

  if (likely(topo != NULL))
    {
      mctop_hwcid_fix_numa_node(topo, cpu);
    }
#endif

  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x29eb
pushq $0x1
popq %rax
movl %ebx, %ecx
shlq %cl, %rax
movl %ebx, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
movq %rsp, %rdx
movl $0x80, %esi
xorl %edi, %edi
callq 0x2130
movl %eax, %ebp
testq %r14, %r14
je 0x2a0b
movq %r14, %rdi
movl %ebx, %esi
callq 0x8d5f
xorl %eax, %eax
testl %ebp, %ebp
sete %al
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop.c
// Function: is_smt
void*
is_smt(void* param)
{
  tld_t* tld = (tld_t*) param;
  const int tid = tld->id;
  const int hwc = tld->hw_context;
  barrier2_t* barrier2 = tld->barrier2;
  pthread_barrier_t* barrier = tld->barrier;

  mctop_set_cpu(NULL, hwc);
  spin_time(test_num_smt_reps >> 8);
  barrier2_cross_explicit(barrier2, tid, 0);

  const int n_smt = 5;
  int is_smt_n = 0;
  for (int i = 0; i < 5; i++)
    {
      barrier2_cross_explicit(barrier2, tid, 2);
      ticks times[2];
      if (tid == 0)
	{
	  times[0] = spin_time(test_num_smt_reps);
	  pthread_barrier_wait(barrier);
	}
      else
	{
	  pthread_barrier_wait(barrier);
	}

      pthread_barrier_wait(barrier);
      barrier2_cross_explicit(barrier2, tid, 1);
      times[1] = spin_time(test_num_smt_reps);
      if (tid == 0)
	{
	  is_smt_n += (times[0] < (times[1] * test_smt_ratio));
	}
    }

  if (tid == 0)
    {
      int* smt = malloc_assert(sizeof(smt));
      *smt = (is_smt_n > (n_smt - is_smt_n));
      return smt;
    }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ebp
movl 0x8(%rdi), %esi
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorl %edi, %edi
callq 0x2998
movl $0x9896, %edi           # imm = 0x9896
callq 0x5d6b
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5f92
xorl %r13d, %r13d
xorl %ebx, %ebx
incl %ebx
movl $0x2, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f92
testl %ebp, %ebp
jne 0x3659
movl $0x989680, %edi         # imm = 0x989680
callq 0x5d6b
movq %rax, %r12
movq %r15, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2090
movl $0x1, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f92
movl $0x989680, %edi         # imm = 0x989680
callq 0x5d6b
testl %ebp, %ebp
je 0x3692
incl %ebx
cmpl $0x6, %ebx
jne 0x3639
jmp 0x3714
movq %r12, %xmm0
movq 0x69b1(%rip), %xmm2     # 0xa050
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x69b5(%rip), %xmm3     # 0xa060
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0x694c(%rip), %xmm2     # 0xa028
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
addl %eax, %r13d
cmpl $0x5, %ebx
jne 0x3637
movl $0x8, %edi
callq 0x21d0
testq %rax, %rax
je 0x3725
movl $0x5, %edx
subl %r13d, %edx
xorl %ecx, %ecx
cmpl %edx, %r13d
setg %cl
movl %ecx, (%rax)
jmp 0x3716
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8c1c(%rip), %rdi      # 0xc348
leaq 0x73cc(%rip), %rsi      # 0xaaff
leaq 0x73de(%rip), %rcx      # 0xab18
movl $0x59, %edx
callq 0x2110
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop.c
// Function: mem_bw_estimate
double
mem_bw_estimate(volatile cache_line_t* mem, const uint do_read, const size_t n, const size_t reps)
{
  volatile uint64_t* m0 = (volatile uint64_t*) mem;
  size_t sum = 0;
  volatile size_t suma = 0;

  const size_t n_warmup = n >> 2;
  for (size_t i = 0; i < n_warmup; i++)
    {
      sum = m0[i];
    }

  struct timespec start, stop;
  clock_gettime(CLOCK_REALTIME, &start);
  if (do_read == BW_READ)
    {
      for (uint r = 0; r < reps; r++)
	{
	  for (size_t i = 0; i < n; i++)
	    {
	      sum = m0[i];
	    }
	}
    }
  else if (do_read == BW_WRITE)
    {
      for (uint r = 0; r < reps; r++)
	{
	  for (size_t i = 0; i < n; i++)
	    {
	      m0[i] = 0xAAAAFFFF;
	    }
	}
    }
  clock_gettime(CLOCK_REALTIME, &stop);

  for (size_t i = 0; i < n_warmup; i++)
    {
      sum = m0[i];
    }


  struct timespec dur = timespec_diff(start, stop);
  double dur_s = dur.tv_sec + (dur.tv_nsec / 1e9);
  if (dur_s == 9)
    {
      printf("%p%zu%zu", m0, sum, suma);
    }

  double bw = (reps * n * sizeof(uint64_t)) / (1e9 * dur_s);
  return bw;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq $0x0, 0x10(%rsp)
movq %rdx, %r13
shrq $0x2, %r13
cmpq $0x4, %rdx
jae 0x3778
xorl %r12d, %r12d
jmp 0x3786
xorl %eax, %eax
movq (%r15,%rax,8), %r12
incq %rax
cmpq %rax, %r13
jne 0x377a
leaq 0x28(%rsp), %rsi
xorl %edi, %edi
callq 0x20b0
testl %ebp, %ebp
je 0x37c3
cmpl $0x1, %ebp
jne 0x37e4
testq %r14, %r14
je 0x37e4
xorl %eax, %eax
movl $0xaaaaffff, %ecx       # imm = 0xAAAAFFFF
testq %rbx, %rbx
je 0x37ba
xorl %edx, %edx
movq %rcx, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0x37ae
incl %eax
cmpq %r14, %rax
jb 0x37a7
jmp 0x37e4
testq %r14, %r14
je 0x37e4
xorl %eax, %eax
testq %rbx, %rbx
je 0x37dd
xorl %ecx, %ecx
movq (%r15,%rcx,8), %r12
incq %rcx
cmpq %rcx, %rbx
jne 0x37d1
incl %eax
cmpq %r14, %rax
jb 0x37ca
leaq 0x18(%rsp), %rsi
xorl %edi, %edi
callq 0x20b0
cmpq $0x4, %rbx
jb 0x3804
xorl %eax, %eax
movq (%r15,%rax,8), %r12
incq %rax
cmpq %rax, %r13
jne 0x37f8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x5bf7
cvtsi2sd %rax, %xmm0
cvtsi2sd %rdx, %xmm2
divsd 0x6801(%rip), %xmm2     # 0xa030
addsd %xmm0, %xmm2
ucomisd 0x67fd(%rip), %xmm2     # 0xa038
jne 0x3864
jp 0x3864
movq 0x10(%rsp), %rcx
leaq 0x6a9b(%rip), %rdi      # 0xa2e6
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
movsd %xmm2, 0x8(%rsp)
callq 0x2100
movsd 0x8(%rsp), %xmm2
imulq %r14, %rbx
shlq $0x3, %rbx
movq %rbx, %xmm1
punpckldq 0x67d7(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x67df(%rip), %xmm1     # 0xa060
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x679b(%rip), %xmm2     # 0xa030
divsd %xmm2, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop.c
// Function: lat_table_normalized_create
ticks**
lat_table_normalized_create(ticks* lat_table, const size_t n, cdf_cluster_t* cc)
{
  ticks** lat_table_norm = malloc_assert(n * sizeof(ticks*));
  for (int i = 0; i < n ; i++)
    {
      lat_table_norm[i] = malloc_assert(n * sizeof(ticks));
    }

  for (size_t x = 0; x < n; x++)
    {
      for (size_t y = 0; y < n; y++)
	{
	  ticks lat = lat_table_2d_get(lat_table, n, x, y);
	  lat_table_norm[x][y] = cdf_cluster_value_to_cluster_median(cc, lat);
	}
    }

  return lat_table_norm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq (,%rsi,8), %r13
movq %r13, %rdi
callq 0x21d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x4f72
testq %r14, %r14
je 0x4f5e
xorl %ebx, %ebx
movq 0x8(%rsp), %r15
movq %r13, %rdi
callq 0x21d0
testq %rax, %rax
je 0x4f72
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq %rbx, %r14
jne 0x4ecd
movq %r14, %rax
shlq $0x20, %rax
movq %rax, 0x18(%rsp)
xorl %r13d, %r13d
movabsq $0x100000000, %r12      # imm = 0x100000000
xorl %r15d, %r15d
movq %r14, 0x10(%rsp)
movq 0x8(%rsp), %rbp
movq %r13, 0x28(%rsp)
xorl %ebx, %ebx
movq 0x20(%rsp), %r14
movq %r13, %rax
sarq $0x1d, %rax
movq (%r14,%rax), %rsi
movq 0x30(%rsp), %rdi
callq 0x65f1
movq (%rbp,%r15,8), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
addq %r12, %r13
cmpq %rbx, 0x10(%rsp)
jne 0x4f1c
incq %r15
movq 0x28(%rsp), %r13
addq 0x18(%rsp), %r13
movq 0x10(%rsp), %r14
cmpq %r14, %r15
jne 0x4f10
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73cf(%rip), %rdi      # 0xc348
leaq 0x5b7f(%rip), %rsi      # 0xaaff
leaq 0x5b91(%rip), %rcx      # 0xab18
movl $0x59, %edx
callq 0x2110
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop.c
// Function: lat_table_get_hwc_with_lat
int
lat_table_get_hwc_with_lat(ticks** lat_table, const size_t n, ticks target_lat, int* hwcs)
{
  for (int x = 0; x < n; x++)
    {
      for (int y = 0; y < n; y++)
	{
	  if (lat_table[x][y] == target_lat)
	    {
	      hwcs[0] = x;
	      hwcs[1] = y;
	      return 1;
	    }
	}
    }
  return 0;
}

// Assembly:
testq %rsi, %rsi
je 0x4fbc
movb $0x1, %r8b
xorl %eax, %eax
movq (%rdi,%rax,8), %r10
xorl %r9d, %r9d
cmpq %rdx, (%r10,%r9,8)
je 0x4fbf
incq %r9
cmpq %r9, %rsi
jne 0x4fa2
incq %rax
cmpq %rsi, %rax
setb %r8b
jne 0x4f9b
xorl %eax, %eax
retq
movl %eax, (%rcx)
movl %r9d, 0x4(%rcx)
movzbl %r8b, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop.c
// Function: print_cache_info
void 
print_cache_info(mctop_cache_info_t* mci, test_format_t test_format, const char* hostname)
{
  if (test_format == MCT_FILE)
    {
      printf("## Cache info ############################################################\n");
      char out_file[50];
      sprintf(out_file, "./desc/%s.mct", hostname);
      printf("## MCTOP output in: %s\n", out_file);

      int ofp_open = 1;
      FILE* ofp = fopen(out_file, "a");
      if (ofp == NULL) 
	{
	  ofp_open = 0;
	  fprintf(stderr, "MCTOP Error: Cannot open output file %s! Using stderr instead.\n", out_file);
	  ofp = stderr;
	}

      fprintf(ofp, "#Cache_levels %d\n", mci->n_levels);
      for (int i = 0; i < mci->n_levels; i++)
	{
	  fprintf(ofp, "Cache_level %d   Latency %-5zu  SizeOS %-5zu SizeEst %-5zu\n",
		  i, mci->latencies[i], mci->sizes_OS[i], mci->sizes_estimated[i]);
	}
      if (ofp_open)
	{
	  fclose(ofp);
	}
      printf("##########################################################################\n");
    }
}

// Assembly:
cmpl $0x3, %esi
jne 0x55ec
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x616a(%rip), %rdi      # 0xb695
callq 0x2080
leaq 0x5235(%rip), %rsi      # 0xa76c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22b0
leaq 0x522c(%rip), %rdi      # 0xa77a
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
leaq 0x52a6(%rip), %rsi      # 0xa805
movq %r15, %rdi
callq 0x2240
movq %rax, %r14
movq %rax, %r15
testq %rax, %rax
je 0x55ed
movl (%rbx), %edx
leaq 0x528c(%rip), %rsi      # 0xa807
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
cmpl $0x0, (%rbx)
je 0x55c6
leaq 0x5288(%rip), %r12      # 0xa819
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
movq (%rax,%r13,8), %rcx
movq (%rdx,%r13,8), %r8
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %r9
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x2170
incq %r13
movl (%rbx), %eax
cmpq %rax, %r13
jb 0x5594
testq %r14, %r14
je 0x55d3
movq %r15, %rdi
callq 0x20e0
leaq 0x6151(%rip), %rdi      # 0xb72b
callq 0x2080
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa9fc(%rip), %r15      # 0xfff0
movq (%r15), %rdi
leaq 0x5197(%rip), %rsi      # 0xa795
movq %rsp, %rdx
xorl %eax, %eax
callq 0x2170
movq (%r15), %r15
jmp 0x5572
// File: /workspace/github_c_makefile_star2_O3/LPD-EPFL[P]mctop/src/mctop_profiler.c
// Function: mctop_prof_create
mctop_prof_t*
mctop_prof_create(size_t num_entries)
{
  mctop_prof_t* prof = malloc_assert(sizeof(mctop_prof_t) + (num_entries * sizeof(ticks)));

  prof->size = num_entries;
  prof->correction = 0;
  prof->correction = mctop_prof_correction_calc(prof, num_entries);
  return prof;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x40(,%rdi,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x5991
movq %rax, %r14
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x5ece(%rip), %xmm0     # 0xb7b0
movl $0xf4240, %edi          # imm = 0xF4240
xorl %esi, %esi
callq 0x5dbd
movl $0x8, %r12d
leaq 0x10(%rsp), %r15
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
jae 0x593e
rdtsc
movl %edx, %ecx
movl %eax, %esi
negl %ecx
shlq $0x20, %rcx
rdtsc
movl %eax, %eax
shlq $0x20, %rdx
addq %rax, %rdx
addq 0x8(%r14), %rsi
subq %rsi, %rcx
addq %rdx, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%r14,%rax,8)
incq 0x8(%rsp)
jmp 0x5902
movq %r14, %rdi
movq %r15, %rsi
callq 0x59b5
movsd 0x30(%rsp), %xmm0
movq %r12, %xmm1
incq %r12
punpckldq 0x46f1(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x46f9(%rip), %xmm1     # 0xa060
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
ja 0x58f9
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x69b0(%rip), %rdi      # 0xc348
leaq 0x5160(%rip), %rsi      # 0xaaff
leaq 0x5172(%rip), %rcx      # 0xab18
movl $0x59, %edx
callq 0x2110