LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: parse_name
static void
parse_name(char *buf, size_t size, const char *name_template, unsigned int ctx_num)
{
	struct timespec ts_now;
	int in_escape=0;
	size_t pos=0;
	char c;

	buf[--size]=0; /* resverve space for final NUL terminator */
	while ( (pos < size) && (c=*(name_template++)) ) {
		if (in_escape) {
			switch(c) {
				case '%':
					buf[pos++]=c;
					break;
				case 'c':
					pos=buf_printf(buf,pos,size,"%u",ctx_num);
					break;
				case 'p':
					pos=buf_printf(buf,pos,size,"%u",(unsigned)getpid());
					break;
				case 't':
					clock_gettime(CLOCK_REALTIME, &ts_now);
					pos=buf_printf(buf,pos,size,"%09lld.%ld",
							(long long)ts_now.tv_sec,
							ts_now.tv_nsec);
					break;
				default:
					pos=buf_printf(buf,pos,size,"%%%c",c);
			}
			in_escape=0;
		} else {
			switch(c) {
				case '%':
					in_escape=1;
					break;
				default:
					buf[pos++]=c;
			}
		}
	}
	buf[pos]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0xfff(%rdi)
xorl %r13d, %r13d
leaq 0x165b(%rip), %r15      # 0x74e0
xorl %r12d, %r12d
movsbl (%r14), %r8d
testl %r8d, %r8d
je 0x5f56
testl %r12d, %r12d
je 0x5ef7
movzbl %r8b, %eax
cmpl $0x6f, %eax
jg 0x5ebe
cmpl $0x25, %eax
je 0x5f1b
cmpl $0x63, %eax
jne 0x5f09
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
movl %ebp, %r8d
jmp 0x5f3c
cmpl $0x70, %eax
je 0x5f28
cmpl $0x74, %eax
jne 0x5f09
xorl %r12d, %r12d
xorl %edi, %edi
leaq 0x8(%rsp), %rsi
callq 0x2080
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x15f5(%rip), %rcx      # 0x74e3
xorl %eax, %eax
callq 0x5f6a
jmp 0x5f43
movl $0x1, %r12d
cmpb $0x25, %r8b
je 0x5f46
movb %r8b, (%rbx,%r13)
jmp 0x5f20
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x15d5(%rip), %rcx      # 0x74ee
jmp 0x5f3c
movb $0x25, (%rbx,%r13)
incq %r13
xorl %r12d, %r12d
jmp 0x5f46
callq 0x2090
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x5f6a
movq %rax, %r13
incq %r14
cmpq $0xfff, %r13            # imm = 0xFFF
jb 0x5e88
movb $0x0, (%rbx,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: GH_get_gl_proc
static void *
GH_get_gl_proc(const char *name)
{
	static void *proc;

	/* try glXGetProcAddressARB first */
	GH_GET_PTR(glXGetProcAddressARB);
	if (GH_glXGetProcAddressARB && (proc=GH_glXGetProcAddressARB(name)) )
		return proc;

	/* try glXGetProcAddress as second chance */
	GH_GET_PTR(glXGetProcAddress);
	if (GH_glXGetProcAddress && (proc=GH_glXGetProcAddress(name)) )
		return proc;

	/* try dlsym as last resort */
	return GH_dlsym_gl(name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5147(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x5172(%rip)      # 0xb1a8
jne 0x6082
cmpq $0x0, 0x5158(%rip)      # 0xb198
je 0x605e
movq 0x514f(%rip), %rax      # 0xb198
leaq 0x1077(%rip), %rsi      # 0x70c7
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x607b
leaq 0x1418(%rip), %rsi      # 0x747d
leaq 0x105b(%rip), %rdx      # 0x70c7
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x2cac
movq %r14, 0x5126(%rip)      # 0xb1a8
leaq 0x50e7(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x5112(%rip)      # 0xb1a8
je 0x60b4
movq 0x5109(%rip), %rax      # 0xb1a8
movq %rbx, %rdi
callq *%rax
movq %rax, 0x51cd(%rip)      # 0xb278
testq %rax, %rax
jne 0x6142
leaq 0x50b5(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x50d8(%rip)      # 0xb1a0
jne 0x6114
cmpq $0x0, 0x50c6(%rip)      # 0xb198
je 0x60f0
movq 0x50bd(%rip), %rax      # 0xb198
leaq 0xfb5(%rip), %rsi       # 0x7097
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x610d
leaq 0x1386(%rip), %rsi      # 0x747d
leaq 0xf99(%rip), %rdx       # 0x7097
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x2cac
movq %r14, 0x508c(%rip)      # 0xb1a0
leaq 0x5055(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x5078(%rip)      # 0xb1a0
je 0x614a
movq 0x506f(%rip), %rax      # 0xb1a0
movq %rbx, %rdi
callq *%rax
movq %rax, 0x513b(%rip)      # 0xb278
testq %rax, %rax
je 0x614a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b35
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: get_envui
static unsigned int
get_envui(const char *name, unsigned int def)
{
	const char *s=getenv(name);
	int i;

	if (s) {
		i=(unsigned)strtoul(s,NULL,0);
	} else {
		i=def;
	}
	return i;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x2030
testq %rax, %rax
je 0x66a4
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2170
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: frametimes_flush
static void
frametimes_flush(GH_frametimes *ft)
{
	unsigned int i;
	GH_frametime *last;
	const GH_frametime *cur,*prev=&ft->frametime[ft->num_results * ft->num_timestamps];

	if (ft->cur_result == 0) {
		return;
	}

	GH_verbose(GH_MSG_DEBUG, "frametimes: dumping results of %u frames\n", ft->cur_result);
	for (i=0; i<ft->cur_result; i++) {
		unsigned int frame=ft->frame - ft->cur_result + i;
		if (frame >= ft->delay) {
			fprintf(ft->dump, "%u", frame - ft->delay);
			cur=&ft->frametime[i * ft->num_timestamps];
			frametimes_dump_results(ft, cur, prev);
			prev=cur;
			fputc('\n', ft->dump);
		}
	}
	fflush(ft->dump);
	/* copy the last result */
	last=&ft->frametime[ft->num_results * ft->num_timestamps];
	cur=&ft->frametime[(ft->cur_result-1) * ft->num_timestamps];
	for (i=0; i<ft->num_timestamps; i++) {
		last[i]=cur[i];
	}


	ft->cur_result=0;
}

// Assembly:
movl 0x28(%rdi), %edx
testl %edx, %edx
je 0x6841
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movl 0x8(%rdi), %r15d
movl 0xc(%rdi), %ebp
leaq 0x1a6c(%rip), %rsi      # 0x8142
movl $0x4, %edi
xorl %eax, %eax
callq 0x2cac
movl 0x28(%rbx), %eax
testl %eax, %eax
je 0x67d7
imull %ebp, %r15d
leaq (%r15,%r15,2), %rcx
leaq (%r14,%rcx,8), %r12
leaq 0x1a6c(%rip), %r15      # 0x816c
xorl %ebp, %ebp
movl 0x2c(%rbx), %edx
subl %eax, %edx
addl %ebp, %edx
subl 0x4(%rbx), %edx
jb 0x67cd
movq 0x30(%rbx), %rdi
leaq 0xdc3(%rip), %rsi       # 0x74e0
xorl %eax, %eax
callq 0x2100
movq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rbx), %eax
movl %eax, %ecx
imull %ebp, %ecx
movq %rcx, 0x8(%rsp)
testl %eax, %eax
je 0x67aa
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
addq $0x10, %r13
xorl %r14d, %r14d
movq -0x10(%r13), %rdx
movq 0x30(%rbx), %rdi
subq 0x18(%r12), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdx
movq 0x30(%rbx), %rdi
subq 0x28(%r12), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdx
movq 0x30(%rbx), %rdi
subq -0x8(%r13), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
incq %r14
movl 0x8(%rbx), %eax
addq $0x18, %r13
cmpq %rax, %r14
jb 0x6757
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r12
movq 0x30(%rbx), %rsi
movl $0xa, %edi
callq 0x20d0
movl 0x28(%rbx), %eax
incl %ebp
cmpl %eax, %ebp
jb 0x6702
movq 0x30(%rbx), %rdi
callq 0x2140
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x682c
movq 0x20(%rbx), %rax
movl 0xc(%rbx), %edx
imull %ecx, %edx
movl 0x28(%rbx), %esi
decl %esi
imull %ecx, %esi
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %rcx
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdx
xorl %esi, %esi
movq 0x10(%rax,%rdx), %rdi
movq %rdi, 0x10(%rax,%rcx)
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rax,%rcx)
incq %rsi
movl 0x8(%rbx), %edi
addq $0x18, %rax
cmpq %rdi, %rsi
jb 0x680b
movl $0x0, 0x28(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: timestamp_set
static void
timestamp_set(GH_timestamp *ts, GH_frametime *rs, GH_frametime_mode mode)
{
	/* CPU */
	/* collect previous result */
	rs->cpu=(uint64_t)ts->timestamp_cpu.tv_sec * (uint64_t)1000000000UL
		+ (uint64_t)ts->timestamp_cpu.tv_nsec;
	/* new query */
	clock_gettime(CLOCK_REALTIME, &ts->timestamp_cpu);

	/* GPU */
	if (mode >= GH_FRAMETIME_CPU_GPU) {
		/* collect previous result */
		if (ts->query_object) {
			GLuint64 value;
			GH_glGetQueryObjectui64v(ts->query_object, GL_QUERY_RESULT, &value);
			rs->gpu=(uint64_t)value;
		} else {
			GH_glGenQueries(1, &ts->query_object);
		}
		rs->gl=(uint64_t)(ts->timestamp_gl);
		/* new query */
		GH_glQueryCounter(ts->query_object, GL_TIMESTAMP);
		GH_glGetInteger64v(GL_TIMESTAMP, (GLint64*)&ts->timestamp_gl);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
imulq $0x3b9aca00, (%rdi), %rax # imm = 0x3B9ACA00
movq %rsi, %r14
addq 0x8(%rdi), %rax
movq %rax, (%rsi)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2080
cmpl $0x2, %ebp
jb 0x68c6
movl 0x18(%rbx), %edi
testl %edi, %edi
je 0x688f
movq %rsp, %r15
movl $0x8866, %esi           # imm = 0x8866
movq %r15, %rdx
callq *0x4a6a(%rip)           # 0xb2f0
movq (%r15), %rax
movq %rax, 0x10(%r14)
jmp 0x689e
leaq 0x18(%rbx), %rsi
movl $0x1, %edi
callq *0x4a32(%rip)           # 0xb2d0
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl 0x18(%rbx), %edi
movl $0x8e28, %esi           # imm = 0x8E28
callq *0x4a30(%rip)           # 0xb2e8
movl $0x8e28, %edi           # imm = 0x8E28
movq %r15, %rsi
callq *0x4a1a(%rip)           # 0xb2e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: path_destroy
void path_destroy(path_t *path)
{
    if (path->sid)
        free(path->sid);
    if (path->v)
        free(path->v);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4cc1
callq 0x3060
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4cd0
popq %rbx
jmp 0x3060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: path_v_destroy
void path_v_destroy(path_v *path)
{
    size_t i;
    for (i = 0; i < path->n; ++i)
        path_destroy(&path->a[i]);
    free(path->a);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4cfe
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0x4cb0
incq %r15
addq $0x30, %r14
cmpq (%rbx), %r15
jb 0x4ce6
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_seg_len
uint64_t asg_seg_len(asg_t *asg)
{
    asmg_t *g = asg->asmg;
    uint64_t i, seg_len = 0;
    for (i = 0; i < g->n_vtx; ++i) {
        if (g->vtx[i].del) continue;
        seg_len += g->vtx[i].len;
    }
    return seg_len;
}

// Assembly:
movq 0x20(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x4d36
movq 0x10(%rax), %rdx
addq $0x20, %rdx
xorl %eax, %eax
testb $0x40, 0x3(%rdx)
jne 0x4d2c
addq -0x8(%rdx), %rax
addq $0x28, %rdx
decq %rcx
jne 0x4d22
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: add_next
static void add_next(llnode *node, struct list_node *next)
{
    if (node->n_m == node->n_n)
        MYEXPAND(node->next, node->n_m);
    node->next[node->n_n] = next;
    node->n_n++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jne 0x8738
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
orq %rcx, %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x20(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x3330
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rcx
jmp 0x873c
movq 0x20(%rbx), %rax
movq %r14, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: llnode_destroy
static void llnode_destroy(llnode *node)
{
    size_t i;
    for (i = 0; i < node->n_n; ++i)
        llnode_destroy(node->next[i]);
    free(node->next);
    free(node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x8776
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x874f
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x8760
movq 0x20(%rbx), %rdi
callq 0x3060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_name2id
uint32_t asg_name2id(asg_t *g, char *name)
{
    sdhash_t *h = g->h_seg;
    khint_t k;
    k = kh_sdict_get(h, name);
    return k == kh_end(h)? UINT32_MAX : kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %r9
movq 0x10(%r9), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x8c8b
movq %rsi, %r14
movl (%r9), %ecx
movl $0x1, %eax
shll %cl, %eax
movsbl (%rsi), %edx
testl %edx, %edx
je 0x8c38
movb 0x1(%r14), %sil
testb %sil, %sil
je 0x8c3a
leaq 0x2(%r14), %rdi
movl %edx, %r8d
shll $0x5, %r8d
subl %edx, %r8d
movsbl %sil, %edx
addl %r8d, %edx
movb (%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x8c1a
jmp 0x8c3a
xorl %edx, %edx
imull $0x9e3779b9, %edx, %ebx # imm = 0x9E3779B9
negb %cl
shrl %cl, %ebx
movq %rax, 0x10(%rsp)
leal -0x1(%rax), %r13d
movq 0x8(%r9), %r12
movl %ebx, %ebp
movl %ebp, %eax
shrl $0x5, %eax
movl (%r12,%rax,4), %eax
btl %ebp, %eax
jae 0x8c86
movl %ebp, %r15d
leaq (%r15,%r15,2), %rax
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,4), %rdi
movq %r14, %rsi
callq 0x3250
testl %eax, %eax
je 0x8c9a
incl %ebp
andl %r13d, %ebp
cmpl %ebx, %ebp
jne 0x8c53
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl 0x10(%rsp), %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
je 0x8c8b
leaq (%r15,%r15,2), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx,%rax,4), %eax
jmp 0x8c8b
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: path_sort
void path_sort(path_v *paths)
{
    // sort by wlen -> len -> circ -> nv
    qsort(paths->a, paths->n, sizeof(path_t), pcmpfunc);

    size_t i;
    double b_ll, b_cl;
    b_ll = b_cl = .0;
    for (i = 0 ; i < paths->n; ++i) {
        if (!paths->a[i].circ && paths->a[i].wlen > b_ll)
            b_ll = paths->a[i].wlen;
        if (paths->a[i].circ && paths->a[i].wlen > b_cl)
            b_cl = paths->a[i].wlen;
    }
    if (b_cl >= b_ll)
        b_ll = DBL_MAX;
    // find best
    for (i = 0 ; i < paths->n; ++i) {
        if (!paths->a[i].circ && paths->a[i].wlen >= b_ll)
            paths->a[i].best = 1;
        if (paths->a[i].circ && paths->a[i].wlen >= b_cl)
            paths->a[i].best = 1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rdi
leaq 0xc5(%rip), %rcx        # 0x8d8b
movl $0x30, %edx
callq 0x30c0
movq (%rbx), %rax
testq %rax, %rax
je 0x8d89
movq 0x10(%rbx), %rcx
addq $0x20, %rcx
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testb $0x40, -0x15(%rcx)
movsd (%rcx), %xmm1
jne 0x8d02
ucomisd %xmm2, %xmm1
jbe 0x8d0c
movapd %xmm1, %xmm2
jmp 0x8d0c
ucomisd %xmm0, %xmm1
jbe 0x8d0c
movapd %xmm1, %xmm0
addq $0x30, %rcx
decq %rax
jne 0x8cec
movapd %xmm2, %xmm1
cmpnlesd %xmm0, %xmm1
andpd %xmm1, %xmm2
movsd 0x11766(%rip), %xmm3    # 0x1a490
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movl $0x8, %eax
xorl %ecx, %ecx
movq 0x10(%rbx), %rdx
movl (%rdx,%rax), %esi
btl $0x1e, %esi
jb 0x8d68
movsd 0x18(%rdx,%rax), %xmm2
ucomisd %xmm1, %xmm2
jb 0x8d7d
orl $0x80000000, %esi       # imm = 0x80000000
movl %esi, (%rdx,%rax)
movq 0x10(%rbx), %rdx
movl (%rdx,%rax), %esi
btl $0x1e, %esi
jae 0x8d7d
movsd 0x18(%rdx,%rax), %xmm2
ucomisd %xmm0, %xmm2
jb 0x8d7d
orl $0x80000000, %esi       # imm = 0x80000000
movl %esi, (%rdx,%rax)
incq %rcx
addq $0x30, %rax
cmpq (%rbx), %rcx
jb 0x8d39
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: pcmpfunc
static int pcmpfunc(const void *a, const void *b)
{
    path_t x, y;
    x = *(path_t *) a;
    y = *(path_t *) b;
    if (x.wlen != y.wlen)
        return (x.wlen < y.wlen) - (x.wlen > y.wlen);
    if (x.len != y.len)
        return (x.len < y.len) - (x.len > y.len);
    if (x.circ != y.circ)
        return x.circ? -1 : 1;
    if (x.srcc != y.srcc)
        return (x.srcc < y.srcc) - (x.srcc > y.srcc);
    if (x.nv != y.nv)
        return (x.nv < y.nv) - (x.nv > y.nv);

    return 0;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x20(%rsi), %xmm1
ucomisd %xmm1, %xmm0
jne 0x8d9d
jnp 0x8db2
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
subl %ecx, %eax
retq
movl 0x18(%rsi), %eax
cmpl %eax, 0x18(%rdi)
jne 0x8df6
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
movl %ecx, %eax
shrl $0x1e, %eax
andl $0x1, %eax
btl $0x1e, %edx
movl %eax, %r8d
sbbl $0x0, %r8d
jne 0x8e02
movsd 0x28(%rdi), %xmm0
movsd 0x28(%rsi), %xmm1
ucomisd %xmm1, %xmm0
jne 0x8d9d
jp 0x8d9d
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
andl %eax, %ecx
andl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
je 0x8e01
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
negl %eax
retq
negl %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: path_rotate
void path_rotate(asg_t *g, path_t *path, hmm_annot_db_t *annots, OG_TYPE_t og_type)
{
    double coeff, coeff_rev;
    coeff = path_rotate_core(g, path, annots, og_type);

    rev_path(path);
    coeff_rev = path_rotate_core(g, path, annots, og_type);

    if (coeff > coeff_rev) {
        // redo rev complement
        rev_path(path);
        if (path->circ)
            // make the last element the first
            array_left_rotate(path->v, path->nv-1, path->nv);
    } else {
        coeff = coeff_rev;
    }

    path->srcc = coeff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8f1a
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rax
movl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
andl 0x8(%rbx), %ecx
cmpl $0x2, %ecx
jb 0x8e5f
decl %ecx
decq %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl 0x4(%rax,%rcx,4), %edi
movl %edi, (%rax,%rdx,4)
movl %esi, 0x4(%rax,%rcx,4)
incq %rdx
movl %ecx, %esi
decq %rcx
cmpq %rsi, %rdx
jb 0x8e3c
movl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
andl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x8e7a
xorl %ecx, %ecx
xorb $0x1, (%rax,%rcx,4)
incq %rcx
movl 0x8(%rbx), %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
cmpq %rdx, %rcx
jb 0x8e65
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x8f1a
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8f0a
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %edx
movl %edx, %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x2, %eax
jb 0x8ed4
decl %eax
decq %rax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movl 0x4(%rdi,%rax,4), %esi
movl %esi, (%rdi,%rcx,4)
movl %edx, 0x4(%rdi,%rax,4)
incq %rcx
movl %eax, %edx
decq %rax
cmpq %rdx, %rcx
jb 0x8eaf
movl 0x8(%rbx), %edx
movl %edx, %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
testl %eax, %eax
je 0x8ef1
xorl %eax, %eax
xorb $0x1, (%rdi,%rax,4)
incq %rax
movl 0x8(%rbx), %edx
movl %edx, %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpq %rcx, %rax
jb 0x8eda
btl $0x1e, %edx
jae 0x8f05
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
leal -0x1(%rdx), %esi
callq 0x9da1
movsd (%rsp), %xmm0
movsd %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: array_left_rotate
static void array_left_rotate(uint32_t arr[], uint32_t d, uint32_t n)
{
    uint32_t i, j;
    // if number of elements to be rotated is more than array size
    if(d > n)
        d = d % n;
    if(d == 0 || d == n)
        return;
    i = d;
    j = n - d;
    while (i != j) {
        if(i < j) { // left block arr[0..d-1] is shorter
            swap(arr, d-i, d+j-i, i);
            j -= i;
        } else { // rigth block arr[d..n-1] is shorter
            swap(arr, d-i, d, j);
            i -= j;
        }
    }
    // finally, block swap A and B
    swap(arr, d-i, d, i);
}

// Assembly:
movl %edx, %ecx
cmpl %edx, %esi
jbe 0x9daf
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %esi
testl %esi, %esi
sete %al
subl %esi, %ecx
sete %dl
orb %al, %dl
jne 0x9e5c
xorl %edx, %edx
movl %esi, %eax
cmpl %ecx, %esi
je 0x9e3c
pushq %rbp
pushq %rbx
movl %esi, %eax
movl %eax, %edx
subl %ecx, %edx
jae 0x9e02
testl %eax, %eax
je 0x9dfe
movl %eax, %edx
movl %esi, %r8d
subl %eax, %r8d
movl %r8d, %r9d
movl (%rdi,%r9,4), %r10d
leal (%rcx,%r8), %r11d
movl (%rdi,%r11,4), %ebx
movl %ebx, (%rdi,%r9,4)
movl %r10d, (%rdi,%r11,4)
incl %r8d
decq %rdx
jne 0x9ddf
subl %eax, %ecx
jmp 0x9e2e
testl %ecx, %ecx
je 0x9e2c
movl %ecx, %r8d
negl %eax
movl %esi, %r9d
leal (%rax,%r9), %r10d
movl (%rdi,%r10,4), %r11d
movl %r9d, %ebx
movl (%rdi,%rbx,4), %ebp
movl %ebp, (%rdi,%r10,4)
movl %r11d, (%rdi,%rbx,4)
incl %r9d
decq %r8
jne 0x9e0e
movl %edx, %eax
cmpl %ecx, %eax
jne 0x9dcd
testl %eax, %eax
popq %rbx
popq %rbp
je 0x9e5c
movl %esi, %edx
subl %eax, %edx
movl %eax, %eax
movl %edx, %ecx
movl (%rdi,%rcx,4), %r8d
movl %esi, %r9d
movl (%rdi,%r9,4), %r10d
movl %r10d, (%rdi,%rcx,4)
movl %r8d, (%rdi,%r9,4)
incl %esi
incl %edx
decq %rax
jne 0x9e3e
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: put_chars
static void put_chars(char *seq, int len, int rv, int ow, FILE *fo, uint64_t *l, int line_wd)
{
    int i;
    if (!rv) {
        // forward
        for (i = ow; i < len; ++i) {
            fputc(seq[i], fo);
            if (++(*l) % line_wd == 0)
                fputc('\n', fo);
        }
    } else {
         // reverse
        for (i = len - ow - 1; i >= 0; --i) {
            fputc(comp_table[(int) seq[i]], fo);
            if (++(*l) % line_wd == 0)
                fputc('\n', fo);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movl %esi, %r15d
movq %rdi, %r12
movl 0x40(%rsp), %eax
testl %edx, %edx
je 0xa6c8
movl %ecx, %edx
notl %edx
addl %r15d, %edx
js 0xa70d
movslq %eax, %r13
movl %edx, %eax
subl %ecx, %r15d
addq %rax, %r12
leaq 0xff66(%rip), %rbp      # 0x1a5f0
movsbq (%r12), %rax
movsbl (%rax,%rbp), %edi
movq %r14, %rsi
callq 0x3200
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0xa6bb
movl $0xa, %edi
movq %r14, %rsi
callq 0x3200
decl %r15d
decq %r12
testl %r15d, %r15d
jg 0xa68a
jmp 0xa70d
subl %ecx, %r15d
jle 0xa70d
movslq %eax, %r13
movslq %ecx, %rax
addq %rax, %r12
xorl %ebp, %ebp
movsbl (%r12,%rbp), %edi
movq %r14, %rsi
callq 0x3200
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0xa705
movl $0xa, %edi
movq %r14, %rsi
callq 0x3200
incq %rbp
cmpl %ebp, %r15d
jne 0xa6d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: print_all_best_seqs
void print_all_best_seqs(asg_t *g, path_v *paths, FILE *fo)
{
    if (paths->n == 0)
        return;

    size_t i;
    for (i = 0; i < paths->n; ++i)
        if (!!paths->a[i].best)
            print_seq(g, &paths->a[i], fo, i, 0, 60, 100);
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0xabfb
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
cmpl $0x0, 0x8(%rsi,%r13)
jns 0xabe2
addq %r13, %rsi
movl $0x64, (%rsp)
movq %r15, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
movl $0x3c, %r9d
callq 0xa101
movq (%r14), %rax
incq %r12
addq $0x30, %r13
cmpq %rax, %r12
jb 0xabb2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_destroy
void asg_destroy(asg_t *g)
{
    if (!g) return;
    uint64_t i;
    for (i = 0; i < g->n_seg; ++i)
        asg_seg_destroy(&g->seg[i]);
    free(g->seg);
    // key has been freed by asg_seg_destroy
    if (g->h_seg) kh_sdict_destroy(g->h_seg);
    if (g->asmg) asmg_destroy(g->asmg);
    free(g);
}

// Assembly:
testq %rdi, %rdi
je 0xacf0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xac96
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %r12
movq -0x8(%r12,%r14), %rdi
testq %rdi, %rdi
je 0xac7b
callq 0x3060
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0xac89
callq 0x3060
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jb 0xac68
movq 0x10(%rbx), %rdi
callq 0x3060
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xaccf
movq 0x10(%r14), %rsi
movq 0x18(%r14), %r15
movq %r15, %rdi
callq 0x18b4b
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x18b4b
movq %r15, %rdi
movq %r14, %rsi
callq 0x18b4b
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xacdd
callq 0x11ef0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_add_seg
uint32_t asg_add_seg(asg_t *g, char *name, int allow_dups)
{
    if (!name)
        return UINT32_MAX;
    sdhash_t *h = g->h_seg;
    khint_t k;
    int absent;
    k = kh_sdict_put(h, name, &absent);
    if (absent) {
        asg_seg_t *s;
        if (g->n_seg == g->m_seg)
            MYEXPAND(g->seg, g->m_seg);
        s = &g->seg[g->n_seg];
        s->len = 0;
        s->seq = 0;
        s->cov = 0;
        kh_key(h, k) = s->name = strdup(name);
        kh_val(h, k) = g->n_seg++;
    } else if (!allow_dups) {
        fprintf(stderr, "[E::%s] duplicate segment '%s'\n", __func__, name);
        exit(EXIT_FAILURE);
    }
    return kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xad9d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r13, %rdx
callq 0xae10
cmpl $0x0, (%r13)
je 0xada5
movl %eax, (%rsp)
movq 0x8(%rbx), %r12
cmpq (%rbx), %r12
jne 0xadbb
movq %r12, %rax
shrq %rax
orq %r12, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
leaq 0x8(,%rcx,8), %rax
leaq (%rax,%rax,2), %rsi
callq 0x3330
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %r12
jmp 0xadbf
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0xadf6
testl %r12d, %r12d
je 0xae08
movq 0x10(%r15), %rdx
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rdx,%rcx,4), %r12d
jmp 0xadf6
movq 0x10(%rbx), %r13
leaq (%r12,%r12,2), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13,%rbp,8)
movq %r14, %rdi
callq 0x3480
movq %rax, (%r13,%rbp,8)
movq 0x10(%r15), %rcx
movl (%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq %rax, (%rcx,%rdx,4)
leaq 0x1(%r12), %rax
movq %rax, 0x8(%rbx)
movl %r12d, 0x8(%rcx,%rdx,4)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3809
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_add_seg1
uint32_t asg_add_seg1(asg_t *g, char *name, char *seq, uint32_t len, uint64_t cov, int allow_dups)
{
    uint32_t k = asg_add_seg(g, name, allow_dups);
    asg_seg_t *s = &g->seg[k];
    s->seq = strdup(seq);
    s->len = len;
    s->cov = cov;
    return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
movl %r9d, %edx
callq 0xacf1
movl %eax, %r12d
movq 0x10(%r15), %r15
movl %eax, %eax
leaq (%rax,%rax,2), %r13
movq %r14, %rdi
callq 0x3480
movq %rax, 0x8(%r15,%r13,8)
movl %ebp, 0x10(%r15,%r13,8)
movl %ebx, 0x14(%r15,%r13,8)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_make_copy
asg_t *asg_make_copy(asg_t *asg)
{
    uint64_t i;
    khint_t k;
    int absent;

    // seg sequence not copied
    asg_t *asg1 = asg_init();
    asg_seg_t *seg, *seg1;
    asg1->m_seg = asg1->n_seg = asg->n_seg;
    MYCALLOC(asg1->seg, asg1->n_seg);
    kh_sdict_t *h_seg = (kh_sdict_t *) asg1->h_seg;
    for (i = 0; i < asg1->n_seg; ++i) {
        seg = &asg->seg[i];
        seg1 = &asg1->seg[i];
        seg1->name = strdup(seg->name);
        seg1->len = seg->len;
        seg1->cov = seg->cov;
        k = kh_sdict_put(h_seg, seg1->name, &absent);
        kh_val(h_seg, k) = i;
    }
    asg_make_asmg_copy(asg->asmg, asg1->asmg);

    return asg1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0xabfc
movq %rax, %rbx
movq 0x8(%r14), %r15
movq %r15, 0x8(%rax)
movq %r15, (%rax)
movl $0x18, %esi
movq %r15, %rdi
callq 0x3240
movq %rbx, (%rsp)
movq %rax, 0x10(%rbx)
testq %r15, %r15
je 0xb386
movq %rax, %r12
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x10, %ebx
xorl %ebp, %ebp
movq %r15, %r13
movq %r14, %r15
movq 0x10(%r14), %r14
movq -0x10(%r14,%rbx), %rdi
callq 0x3480
movq %rax, -0x10(%r12,%rbx)
movq (%r14,%rbx), %rcx
movq %r15, %r14
movq %r13, %r15
movq %rcx, (%r12,%rbx)
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
leaq 0x14(%rsp), %rdx
callq 0xae10
movq 0x10(%r13), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl %ebp, 0x8(%rcx,%rax,4)
incq %rbp
addq $0x18, %rbx
cmpq %rbp, %r15
jne 0xb330
movq 0x20(%r14), %rdi
movq (%rsp), %rbx
movq 0x20(%rbx), %rsi
callq 0xb1fb
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_print
void asg_print(asg_t *g, FILE *fo, int no_seq)
{
    uint32_t i, cov;
    uint64_t k;
    asmg_t *asmg = g->asmg;

    fprintf(fo, "H\tVN:Z:1.0\n");
    for (i = 0; i < g->n_seg; ++i) {
        const asg_seg_t *s = &g->seg[i];
        // seg and vtx indices are interchangeable
        if (asmg && asmg->vtx[i].del) continue;
        cov = asmg? asmg->vtx[i].cov : s->cov;
        fprintf(fo, "S\t%s\t", s->name);
        if (s->seq && !no_seq) fputs(s->seq, fo);
        else fputc('*', fo);
        fprintf(fo, "\tLN:i:%u\tKC:i:%lu\tSC:f:%.3f\n", s->len, (uint64_t)s->len*cov, (double)cov);
    }

    if (asmg == 0) return;
    for (k = 0; k < asmg->n_arc; ++k) {
        const asmg_arc_t *a = &asmg->arc[k];
        if (a->del || a->comp) continue;
        fprintf(fo, "L\t%s\t%c\t%s\t%c\t%luM\tEC:i:%u\n", g->seg[a->v>>1].name, "+-"[a->v&1], 
                g->seg[a->w>>1].name, "+-"[a->w&1], a->ls, a->cov);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r13
leaq 0xf5b5(%rip), %rdi      # 0x1ac62
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3450
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb77b
movl $0x1, %r15d
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %r12
shlq $0x3, %r12
addq 0x10(%r14), %r12
testq %r13, %r13
je 0xb6ff
movq 0x10(%r13), %rdx
leaq (%rcx,%rcx,4), %rcx
movl 0x20(%rdx,%rcx,8), %ebp
btl $0x1e, %ebp
jb 0xb76c
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
jmp 0xb704
movl 0x14(%r12), %ebp
movq (%r12), %rdx
movq %rbx, %rdi
leaq 0xf55c(%rip), %rsi      # 0x1ac6e
xorl %eax, %eax
callq 0x3290
cmpl $0x0, 0x4(%rsp)
jne 0xb734
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0xb734
movq %rbx, %rsi
callq 0x31a0
jmp 0xb741
movl $0x2a, %edi
movq %rbx, %rsi
callq 0x3200
movl 0x10(%r12), %edx
movl %ebp, %eax
movq %rdx, %rcx
imulq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
leaq 0xf513(%rip), %rsi      # 0x1ac74
movb $0x1, %al
callq 0x3290
movq 0x8(%r14), %rax
movl %r15d, %ecx
incl %r15d
cmpq %rcx, %rax
ja 0xb6d4
testq %r13, %r13
je 0xb817
movq 0x18(%r13), %rax
testq %rax, %rax
je 0xb817
movl $0x20, %r12d
leaq 0xf0be(%rip), %rbp      # 0x1a85c
xorl %r15d, %r15d
movq 0x28(%r13), %r10
movl (%r10,%r12), %r11d
cmpl $0x3fffffff, %r11d      # imm = 0x3FFFFFFF
ja 0xb80b
movq 0x10(%r14), %rax
movq -0x20(%r10,%r12), %rcx
movq -0x18(%r10,%r12), %rsi
movq %rcx, %rdx
shrq %rdx
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,8), %rdx
andl $0x1, %ecx
movsbl (%rcx,%rbp), %ecx
movq %rsi, %rdi
shrq %rdi
leaq (%rdi,%rdi,2), %rdi
movq (%rax,%rdi,8), %r8
andl $0x1, %esi
movsbl (%rsi,%rbp), %r9d
movq %rbx, %rdi
leaq 0xf49c(%rip), %rsi      # 0x1ac91
xorl %eax, %eax
pushq %r11
pushq -0x8(%r10,%r12)
callq 0x3290
addq $0x10, %rsp
movq 0x18(%r13), %rax
incq %r15
addq $0x30, %r12
cmpq %rax, %r15
jb 0xb7a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: sequence_covered_by_path
double sequence_covered_by_path(asg_t *asg, path_t *path, uint32_t len)
{
    uint32_t i, n, l, *v;
    uint8_t *flag;
    MYCALLOC(flag, asg->n_seg);
    v = path->v;
    l = 0;
    for (i = 0, n = path->nv; i < n; ++i) {
        if (!flag[v[i]>>1]) {
            l += asg->seg[v[i]>>1].len;
            flag[v[i]>>1] = 1;
        }
    }
    free(flag);
    return (double) l / len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movl $0x1, %esi
callq 0x3240
movl 0x8(%r15), %ecx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
je 0xbaec
movq 0x10(%r15), %rdx
xorl %esi, %esi
xorl %edi, %edi
movl (%rdx,%rsi,4), %r8d
shrl %r8d
cmpb $0x0, (%rax,%r8)
jne 0xbadb
movq 0x10(%r14), %r9
leaq (%r8,%r8,2), %r10
addl 0x10(%r9,%r10,8), %edi
movb $0x1, (%rax,%r8)
incq %rsi
cmpq %rsi, %rcx
jne 0xbabb
movl %edi, %ecx
cvtsi2sd %rcx, %xmm0
jmp 0xbaf0
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rax, %rdi
callq 0x3060
movl %ebx, %eax
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: is_valid_gfa_tag
int is_valid_gfa_tag(const char *tag)
{
    int is_valid = 0;
    if (strlen(tag) != 4)
        return is_valid;
    is_valid = isalpha(tag[0]) && 
        (isalpha(tag[1]) || isdigit(tag[1])) && 
        (tag[2] == ':') &&
        (tag[3] == 'A' || tag[3] == 'i' || tag[3] == 'f' || tag[3] == 'Z' || tag[3] == 'B');
    return is_valid;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3130
xorl %ebx, %ebx
cmpq $0x4, %rax
jne 0xbb75
callq 0x34d0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0xbb75
movsbq 0x1(%r14), %rcx
testb $0xc, 0x1(%rax,%rcx,2)
je 0xbb75
cmpb $0x3a, 0x2(%r14)
jne 0xbb75
movzbl 0x3(%r14), %eax
leal -0x41(%rax), %ecx
cmpl $0x28, %ecx
ja 0xbb7f
movl $0x1, %ebx
movabsq $0x12002000001, %rdx    # imm = 0x12002000001
btq %rcx, %rdx
jae 0xbb7f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
cmpb $0x42, %al
sete %bl
jmp 0xbb75
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_parse_fa_hdr
static int asg_parse_fa_hdr(asg_t *g, char *s, asg_seg_t **seg)
{
    uint64_t i;
    char *c = s;
    while (*c != 0 && !isspace(*c))
        ++c;
    *c = 0;
    if (c - s == 1) // empty
        return PARSE_A_ERR;
    i = asg_add_seg(g, s + 1, 0);
    *seg = &g->seg[i];
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb (%rsi), %bpl
movq %rsi, %rax
testb %bpl, %bpl
je 0xca68
callq 0x34d0
movq (%rax), %rcx
movq %r15, %rax
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0xca68
movb 0x1(%rax), %bpl
incq %rax
testb %bpl, %bpl
jne 0xca51
movb $0x0, (%rax)
subq %r15, %rax
cmpq $0x1, %rax
je 0xca95
incq %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xacf1
movl %eax, %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x10(%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_print_fa
void asg_print_fa(asg_t *g, FILE *fo, int line_wd)
{
    uint64_t i, l;
    for (i = 0; i < g->n_seg; ++i) {
        if (g->asmg && g->asmg->vtx[i].del)
            continue;
        if (g->seg[i].seq == 0)
            fprintf(stderr, "[W::%s] skip empty sequence: %s\n", __func__, g->seg[i].name);
        fprintf(fo, ">%s\n", g->seg[i].name);
        l = 0;
        put_chars(g->seg[i].seq, g->seg[i].len, 0, 0, fo, &l, line_wd);
        if (l % line_wd != 0) fputc('\n', fo);
    }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0xcb9c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
movl $0x20, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xcae2
movq 0x10(%rax), %rax
testb $0x40, 0x3(%rax,%r12)
jne 0xcb4b
movq 0x10(%r14), %rax
cmpq $0x0, 0x8(%rax,%r13)
je 0xcb62
movq (%rax,%r13), %rdx
movq %rbx, %rdi
leaq 0xe1df(%rip), %rsi      # 0x1acdb
xorl %eax, %eax
callq 0x3290
movq $0x0, 0x10(%rsp)
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13), %rdi
movl 0x10(%rax,%r13), %esi
movl %r15d, (%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
leaq 0x10(%rsp), %r9
callq 0xa64c
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
je 0xcb4b
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3200
incq %rbp
addq $0x18, %r13
addq $0x28, %r12
cmpq 0x8(%r14), %rbp
jb 0xcacd
jmp 0xcb8e
movq 0x1348f(%rip), %rcx     # 0x1fff8
movq (%rcx), %rdi
movq (%rax,%r13), %rcx
leaq 0xe136(%rip), %rsi      # 0x1acad
leaq 0xe150(%rip), %rdx      # 0x1acce
xorl %eax, %eax
callq 0x3290
movq 0x10(%r14), %rax
jmp 0xcaee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: og_component_v_destroy
void og_component_v_destroy(og_component_v *component_v)
{
    if (!component_v) return;
    size_t i;
    for (i = 0; i < component_v->n; ++i)
        og_component_destroy(&component_v->a[i]);
    if (component_v->a)
        free(component_v->a);
    free(component_v);
}

// Assembly:
testq %rdi, %rdi
je 0xcc1a
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xcbff
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0xcb9d
incq %r15
addq $0x40, %r14
cmpq (%rbx), %r15
jb 0xcbe7
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xcc0d
callq 0x3060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: asg_vtx_name_list
char **asg_vtx_name_list(asg_t *g, uint64_t *_n)
{
    if (_n) *_n = 0;
    uint64_t i, n = 0;
    uint64_t *vlist = asmg_vtx_list(g->asmg, &n);
    char **names = 0;
    if (n) {
        MYMALLOC(names, n);
        for (i = 0; i < n; ++i)
            names[i] = g->seg[vlist[i]].name;
    }
    free(vlist);
    if (_n) *_n = n;
    return names;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
testq %rsi, %rsi
je 0x110be
movq $0x0, (%rbx)
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0x20(%r12), %rdi
movq %r15, %rsi
callq 0x125b4
movq %rax, %r14
movq (%r15), %r13
testq %r13, %r13
je 0x11113
leaq (,%r13,8), %rdi
callq 0x32f0
movq %rax, %r15
movq 0x10(%r12), %rax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x110f9
jmp 0x11116
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3060
testq %rbx, %rbx
je 0x1112b
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_add2
static inline void asmg_arc_add2(asmg_t *g, uint64_t v, uint64_t w, uint64_t ln, uint64_t ls, uint64_t link_id, uint32_t cov, uint32_t comp)
{
    // add both arc and its comp
    asmg_arc_add(g, v, w, ln, ls, link_id, cov, comp);
    if (v != (w^1) || w != (v^1))
        asmg_arc_add(g, w^1, v^1, ln, ls, link_id, cov, comp^1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbp
movl 0x40(%rsp), %edi
movq 0x18(%rbp), %rcx
cmpq 0x20(%rbp), %rcx
jne 0x111d7
movq %rcx, %rax
shrq %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
incq %rcx
movq %rcx, 0x20(%rbp)
movq 0x28(%rbp), %rdi
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rsi
callq 0x3330
movl 0x40(%rsp), %edi
movq %rax, 0x28(%rbp)
movq 0x18(%rbp), %rcx
jmp 0x111db
movq 0x28(%rbp), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbp)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
movq %rbx, 0x10(%rax,%rcx)
movq %r15, 0x18(%rax,%rcx)
movq $-0x1, 0x28(%rax,%rcx)
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
movl %edi, %edx
shll $0x1f, %edx
orl %r13d, %edx
movl %edx, 0x20(%rax,%rcx)
xorq $0x1, %r12
cmpq %r14, %r12
je 0x112d6
xorq $0x1, %r14
notl %edi
movq 0x18(%rbp), %rcx
cmpq 0x20(%rbp), %rcx
jne 0x1129c
movq %rcx, %rax
shrq %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
incq %rcx
movq %rcx, 0x20(%rbp)
movl %edi, 0x4(%rsp)
movq 0x28(%rbp), %rdi
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rsi
callq 0x3330
movl 0x4(%rsp), %edi
movq %rax, 0x28(%rbp)
movq 0x18(%rbp), %rcx
jmp 0x112a0
movq 0x28(%rbp), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbp)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq %r12, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
movq %rbx, 0x10(%rax,%rcx)
movq %r15, 0x18(%rax,%rcx)
movq $-0x1, 0x28(%rax,%rcx)
shll $0x1f, %edi
orl %r13d, %edi
movl %edi, 0x20(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: gfa_aux_get
static uint8_t *gfa_aux_get(int l_data, const uint8_t *data, const char tag[2])
{
    const uint8_t *s = data;
    int y = tag[0]<<8 | tag[1];
    while (s < data + l_data) {
        int x = (int)s[0]<<8 | s[1];
        s += 2;
        if (x == y) return (uint8_t*)s;
        __skip_tag(s);
    }
    return 0;
}

// Assembly:
testl %edi, %edi
jle 0x11e64
movq %rsi, %rax
movsbl %dl, %edx
shll $0x8, %edx
movsbl %cl, %ecx
orl %edx, %ecx
movslq %edi, %rdx
addq %rsi, %rdx
movabsq $0x120000001, %rsi      # imm = 0x120000001
movabsq $0x400000005, %rdi      # imm = 0x400000005
movzwl (%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %ecx, %r8d
je 0x11e67
movzbl 0x2(%rax), %r9d
leaq 0x3(%rax), %r8
movl $0x1, %r10d
cmpl $0x42, %r9d
jle 0x11dc2
cmpl $0x43, %r9d
je 0x11e25
cmpl $0x63, %r9d
je 0x11e25
cmpl $0x5a, %r9d
jne 0x11dfd
leaq 0x1(%r8), %rax
cmpb $0x0, (%r8)
movq %rax, %r8
jne 0x11db3
jmp 0x11e2b
cmpl $0x41, %r9d
je 0x11e25
cmpl $0x42, %r9d
jne 0x11dfd
movzbl (%r8), %r9d
leal -0x41(%r9), %r11d
cmpl $0x22, %r11d
ja 0x11e36
movl $0x1, %r10d
btq %r11, %rdi
jae 0x11e36
movslq 0x4(%rax), %rax
movl %r10d, %r9d
imulq %rax, %r9
leaq (%r8,%r9), %rax
addq $0x5, %rax
jmp 0x11e2b
movl %r9d, %eax
andb $-0x21, %al
movl $0x2, %r10d
cmpb $0x53, %al
je 0x11e25
addl $-0x49, %r9d
cmpl $0x20, %r9d
ja 0x11e22
movl $0x8, %r10d
btq %r9, %rsi
jb 0x11e25
xorl %r10d, %r10d
addq %r10, %r8
movq %r8, %rax
cmpq %rdx, %rax
jb 0x11d76
jmp 0x11e64
movl %r9d, %r11d
andb $-0x21, %r11b
movl $0x2, %r10d
cmpb $0x53, %r11b
je 0x11de8
addl $-0x49, %r9d
cmpl $0x20, %r9d
ja 0x11e5f
movl $0x8, %r10d
btq %r9, %rsi
jb 0x11de8
xorl %r10d, %r10d
jmp 0x11de8
xorl %eax, %eax
retq
addq $0x2, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/path.c
// Function: gfa_aux_decimal_value
static double gfa_aux_decimal_value(uint8_t *aux)
{
    double val = .0;
    if (*aux == 'c') val = aux_decimal_val(int8_t, aux + 1);
    else if (*aux == 'C') val = aux_decimal_val(uint8_t, aux + 1);
    else if (*aux == 's') val = aux_decimal_val(int16_t, aux + 1);
    else if (*aux == 'S') val = aux_decimal_val(uint16_t, aux + 1);
    else if (*aux == 'i') val = aux_decimal_val(int64_t, aux + 1);
    else if (*aux == 'I') val = aux_decimal_val(uint64_t, aux + 1);
    else if (*aux == 'f') val = aux_decimal_val(double, aux + 1);
    return val;
}

// Assembly:
movzbl (%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $0x62, %eax
jle 0x11e8d
cmpl $0x68, %eax
jg 0x11ea2
cmpl $0x63, %eax
je 0x11eb8
cmpl $0x66, %eax
jne 0x11ecd
movsd 0x1(%rdi), %xmm0
retq
cmpl $0x43, %eax
je 0x11eb2
cmpl $0x49, %eax
je 0x11ece
cmpl $0x53, %eax
jne 0x11ecd
movzwl 0x1(%rdi), %eax
jmp 0x11ebc
cmpl $0x69, %eax
je 0x11ec4
cmpl $0x73, %eax
jne 0x11ecd
movswl 0x1(%rdi), %eax
jmp 0x11ebc
movzbl 0x1(%rdi), %eax
jmp 0x11ebc
movsbl 0x1(%rdi), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
retq
xorps %xmm0, %xmm0
cvtsi2sdq 0x1(%rdi), %xmm0
retq
movsd 0x1(%rdi), %xmm1
unpcklps 0x86b6(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x86be(%rip), %xmm1     # 0x1a5a0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/key.c
// Function: dump_buf
static void
dump_buf(char *msg, uint8_t *buf, size_t buf_len)
{
	fprintf(stderr, "dump_buf: %s\n",msg);
	uint i;
	for (i=0;i<buf_len;i++) {
		if (i % 16 == 8)
			fprintf(stderr, " : ");
		if (i && (i % 16 == 0))
			fprintf(stderr, "\n");
		fprintf(stderr, "%02x ",buf[i]);
	}
	fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x1767b(%rip), %r15     # 0x19fe0
movq %rdx, %rbx
movq %rdi, %rdx
movq %rsi, %r14
leaq 0x1057e(%rip), %rsi     # 0x12ef3
xorl %eax, %eax
movq (%r15), %rdi
callq 0x2390
testq %rbx, %rbx
je 0x29ea
leaq 0x1057a(%rip), %rbp     # 0x12f05
xorl %r13d, %r13d
xorl %r12d, %r12d
movl %r12d, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x29b3
movq (%r15), %rcx
leaq 0x1055b(%rip), %rdi     # 0x12f01
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2550
jmp 0x29cd
testl %r12d, %r12d
sete %cl
testl %eax, %eax
setne %al
orb %cl, %al
jne 0x29cd
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x22e0
movq (%r15), %rdi
movzbl (%r14,%r13), %edx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2390
incl %r12d
cmpq %rbx, %r12
movq %r12, %r13
jb 0x2991
movq (%r15), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22e0
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: atomic_int_create
atomic_int	*
atomic_int_create(uint32_t val)
{
	atomic_int *ai = malloc(sizeof(atomic_int));
	ai->val = val;
	pthread_mutex_init(&ai->lock,0);
	return(ai);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x30, %edi
callq 0x22f0
leaq 0x8(%rax), %rdi
xorl %esi, %esi
movq %rax, %r14
movl %ebx, (%rax)
callq 0x2410
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq