LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: latency_gl_init
static int
latency_gl_init()
{
	GH_GET_GL_PROC_OR_FAIL(glFenceSync, GH_MSG_WARNING, -1);
	GH_GET_GL_PROC_OR_FAIL(glDeleteSync, GH_MSG_WARNING, -1);
	GH_GET_GL_PROC_OR_FAIL(glClientWaitSync, GH_MSG_WARNING, -1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x5f49(%rip), %rdi      # 0xd218
callq 0x21a0
cmpq $0x0, 0x60bc(%rip)      # 0xd398
jne 0x732f
leaq 0x5f33(%rip), %rdi      # 0xd218
callq 0x2130
leaq 0x2d13(%rip), %rdi      # 0xa004
callq 0x6510
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0x4, %edi
leaq 0x229c(%rip), %rsi      # 0x95a6
leaq 0x2cf3(%rip), %rdx      # 0xa004
movb $0x0, %al
callq 0x3020
leaq 0x5ef9(%rip), %rdi      # 0xd218
callq 0x21a0
movq -0x10(%rbp), %rax
movq %rax, 0x6069(%rip)      # 0xd398
leaq 0x5ee2(%rip), %rdi      # 0xd218
callq 0x2130
cmpq $0x0, 0x6055(%rip)      # 0xd398
jne 0x736b
movl $0x2, %edi
leaq 0x2b4a(%rip), %rsi      # 0x9e9b
leaq 0x2cac(%rip), %rdx      # 0xa004
movb $0x0, %al
callq 0x3020
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74b5
leaq 0x5ea6(%rip), %rdi      # 0xd218
callq 0x21a0
cmpq $0x0, 0x6021(%rip)      # 0xd3a0
jne 0x73d2
leaq 0x5e90(%rip), %rdi      # 0xd218
callq 0x2130
leaq 0x2c7c(%rip), %rdi      # 0xa010
callq 0x6510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x4, %edi
leaq 0x21f9(%rip), %rsi      # 0x95a6
leaq 0x2c5c(%rip), %rdx      # 0xa010
movb $0x0, %al
callq 0x3020
leaq 0x5e56(%rip), %rdi      # 0xd218
callq 0x21a0
movq -0x18(%rbp), %rax
movq %rax, 0x5fce(%rip)      # 0xd3a0
leaq 0x5e3f(%rip), %rdi      # 0xd218
callq 0x2130
cmpq $0x0, 0x5fba(%rip)      # 0xd3a0
jne 0x740e
movl $0x2, %edi
leaq 0x2aa7(%rip), %rsi      # 0x9e9b
leaq 0x2c15(%rip), %rdx      # 0xa010
movb $0x0, %al
callq 0x3020
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74b5
leaq 0x5e03(%rip), %rdi      # 0xd218
callq 0x21a0
cmpq $0x0, 0x5f86(%rip)      # 0xd3a8
jne 0x7475
leaq 0x5ded(%rip), %rdi      # 0xd218
callq 0x2130
leaq 0x2be6(%rip), %rdi      # 0xa01d
callq 0x6510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl $0x4, %edi
leaq 0x2156(%rip), %rsi      # 0x95a6
leaq 0x2bc6(%rip), %rdx      # 0xa01d
movb $0x0, %al
callq 0x3020
leaq 0x5db3(%rip), %rdi      # 0xd218
callq 0x21a0
movq -0x20(%rbp), %rax
movq %rax, 0x5f33(%rip)      # 0xd3a8
leaq 0x5d9c(%rip), %rdi      # 0xd218
callq 0x2130
cmpq $0x0, 0x5f1f(%rip)      # 0xd3a8
jne 0x74ae
movl $0x2, %edi
leaq 0x2a04(%rip), %rsi      # 0x9e9b
leaq 0x2b7f(%rip), %rdx      # 0xa01d
movb $0x0, %al
callq 0x3020
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74b5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74f7
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2180
movl %eax, -0x1c(%rbp)
jmp 0x74fd
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: remove_ctx
static void
remove_ctx(GLXContext ctx)
{
	gl_context_t *glc,*prev=NULL;

	pthread_mutex_lock(&ctx_mutex);
	for (glc=ctx_list; glc; glc=glc->next) {
		if (glc->ctx == ctx)
			break;
		prev=glc;
	}
	if (glc) {
		if (prev) 
			prev->next=glc->next;
		else
			ctx_list=glc->next;
	}
	pthread_mutex_unlock(&ctx_mutex);
	if (glc) {
		destroy_ctx(glc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x5dd5(%rip), %rdi      # 0xd330
callq 0x21a0
movq 0x5e49(%rip), %rax      # 0xd3b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7597
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x7581
jmp 0x7597
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x756b
cmpq $0x0, -0x10(%rbp)
je 0x75c8
cmpq $0x0, -0x18(%rbp)
je 0x75b7
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x75c6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x5dea(%rip)      # 0xd3b0
jmp 0x75c8
leaq 0x5d61(%rip), %rdi      # 0xd330
callq 0x2130
cmpq $0x0, -0x10(%rbp)
je 0x75e4
movq -0x10(%rbp), %rdi
callq 0x75f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: destroy_ctx
static void
destroy_ctx(gl_context_t *glc)
{
	if (glc) {
		frametimes_destroy(&glc->frametimes);
		latency_destroy(&glc->latency);
		swapbuffer_omission_destroy(&glc->swapbuffer_omission);
		free(glc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7636
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x7640
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x7710
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq 0x7790
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: frametimes_destroy
static void
frametimes_destroy(GH_frametimes *ft)
{
	if (ft) {
		unsigned int cnt=ft->delay * ft->num_timestamps;
		unsigned int i;

		frametimes_flush(ft);
		if (ft->dump != NULL && ft->dump != stdout && ft->dump != stderr) {
			fclose(ft->dump);
		}
		for (i=0; i<cnt; i++) {
			timestamp_cleanup(&ft->timestamp[i]);
		}
		free(ft->timestamp);
		free(ft->frametime);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x76fd
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x77f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x76b2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x58b4(%rip), %rcx      # 0xcf40
cmpq (%rcx), %rax
je 0x76b2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x5958(%rip), %rcx      # 0xcff8
cmpq (%rcx), %rax
je 0x76b2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x20a0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x76e3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x10(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x79c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x76b9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: latency_destroy
static void
latency_destroy(GH_latency *lat)
{
	if (lat) {
		if (lat->sync_object && lat->latency > 0) {
			unsigned int i;
			for (i=0; i<(unsigned)lat->latency; i++) {
				if (lat->sync_object[i]) {
					GH_glDeleteSync(lat->sync_object[i]);
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7784
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7782
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x7782
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x7780
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x7773
movq 0x5c3e(%rip), %rax      # 0xd3a0
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x7775
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x773e
jmp 0x7782
jmp 0x7784
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: swapbuffer_omission_destroy
static void
swapbuffer_omission_destroy(GH_swapbuffer_omission_t *swo)
{
	int i;
	for (i=0; i<GH_SWAP_OMISSION_FRAMES_MAX; i++) {
		timestamp_cleanup(&swo->prev_frame_ts[i][0]);
		timestamp_cleanup(&swo->prev_frame_ts[i][1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x77e8
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x79c0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0x79c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x77a3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: find_ctx
static gl_context_t *
find_ctx(GLXContext ctx)
{
	gl_context_t *glc;

	pthread_mutex_lock(&ctx_mutex);
	for (glc=ctx_list; glc; glc=glc->next)
		if (glc->ctx == ctx)
			break;
	pthread_mutex_unlock(&ctx_mutex);
	return glc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x57fd(%rip), %rdi      # 0xd330
callq 0x21a0
movq 0x5871(%rip), %rax      # 0xd3b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7b69
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x7b59
jmp 0x7b69
jmp 0x7b5b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7b43
leaq 0x57c0(%rip), %rdi      # 0xd330
callq 0x2130
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: frametimes_init_base
static void
frametimes_init_base(GH_frametimes *ft)
{
	/* get the base timestamp */
	if (ft->mode > GH_FRAMETIME_NONE) {
		GH_timestamp base;
		unsigned int i;
		GH_frametime *last=&ft->frametime[ft->num_results * ft->num_timestamps];

		timestamp_init(&base);
		timestamp_set(&base, &last[0], ft->mode);
		timestamp_set(&base, &last[0], ft->mode);
		for (i=1; i<ft->num_timestamps; i++) {
			last[i]=last[0];
		}
		timestamp_cleanup(&base);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jbe 0x7c3b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6f30
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq -0x28(%rbp), %rdi
callq 0x7cb0
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq -0x28(%rbp), %rdi
callq 0x7cb0
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x7c32
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7bf3
leaq -0x28(%rbp), %rdi
callq 0x79c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: swapbuffer_omission_init_gl
static void
swapbuffer_omission_init_gl(GH_swapbuffer_omission_t *swo)
{
	if (swo->min_swap_time > 0) {
		if (swapbuffer_omission_init_gl_funcs()) {
			GH_verbose(GH_MSG_WARNING,"adaptive swapbuffer omission not availabe without timer query, disabling it");
			swo->min_swap_time = 0;
			swo->swapbuffers = get_envi("GH_SWAPBUFFERS",0);;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x7ca8
callq 0x7d80
cmpl $0x0, %eax
je 0x7ca6
movl $0x2, %edi
leaq 0x26e5(%rip), %rsi      # 0xa362
movb $0x0, %al
callq 0x3020
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
leaq 0x23a9(%rip), %rdi      # 0xa040
xorl %esi, %esi
callq 0x5480
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x7ca8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
imulq $0x3b9aca00, (%rax), %rcx # imm = 0x3B9ACA00
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x2080
cmpl $0x2, -0x14(%rbp)
jb 0x7d74
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x7d23
movq 0x568d(%rip), %rax      # 0xd390
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %edi
movl $0x8866, %esi           # imm = 0x8866
leaq -0x20(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7d39
movq 0x5646(%rip), %rax      # 0xd370
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x1, %edi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x5638(%rip), %rax      # 0xd388
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %edi
movl $0x8e28, %esi           # imm = 0x8E28
callq *%rax
movq 0x561b(%rip), %rax      # 0xd380
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x8e28, %edi           # imm = 0x8E28
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: translateDebugSourceEnum
static const char *
translateDebugSourceEnum(GLenum source)
{
	const char *s;

	switch (source) {
		case GL_DEBUG_SOURCE_API:
			s="API";
			break;
		case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
			s="window system";
			break;
		case GL_DEBUG_SOURCE_SHADER_COMPILER:
			s="shader compiler";
			break;
		case GL_DEBUG_SOURCE_THIRD_PARTY:
			s="3rd party";
			break;
		case GL_DEBUG_SOURCE_APPLICATION:
			s="application";
			break;
		case GL_DEBUG_SOURCE_OTHER:
			s="other";
			break;
		default:
			s="[UNKNOWN SOURCE]";
	}

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0xffff7dba, %eax       # imm = 0xFFFF7DBA
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x814c
movq -0x18(%rbp), %rax
leaq 0xf0b(%rip), %rcx       # 0x9000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x22c7(%rip), %rax      # 0xa3cc
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22be(%rip), %rax      # 0xa3d0
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22bf(%rip), %rax      # 0xa3de
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22c2(%rip), %rax      # 0xa3ee
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22bf(%rip), %rax      # 0xa3f8
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22be(%rip), %rax      # 0xa404
movq %rax, -0x10(%rbp)
jmp 0x8157
leaq 0x22b7(%rip), %rax      # 0xa40a
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: translateDebugTypeEnum
static const char *
translateDebugTypeEnum(GLenum type)
{
	const char *s;

	switch (type) {
		case GL_DEBUG_TYPE_ERROR:
			s="error";
			break;
		case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
			s="deprecated";
			break;
		case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
			s="undefined behavior";
			break;
		case GL_DEBUG_TYPE_PORTABILITY:
			s="portability";
			break;
		case GL_DEBUG_TYPE_PERFORMANCE:
			s="performance";
			break;
		case GL_DEBUG_TYPE_OTHER:
			s="other";
			break;
		default:
			s="[UNKNOWN TYPE]";
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0xffff7db4, %eax       # imm = 0xFFFF7DB4
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x81dc
movq -0x18(%rbp), %rax
leaq 0xe93(%rip), %rcx       # 0x9018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2322(%rip), %rax      # 0xa4b7
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x2279(%rip), %rax      # 0xa41b
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x2277(%rip), %rax      # 0xa426
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x227d(%rip), %rax      # 0xa439
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x227c(%rip), %rax      # 0xa445
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x222e(%rip), %rax      # 0xa404
movq %rax, -0x10(%rbp)
jmp 0x81e7
leaq 0x226e(%rip), %rax      # 0xa451
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: translateDebugSeverityEnum
static const char *
translateDebugSeverityEnum(GLenum severity)
{
	const char *s;

	switch (severity) {
		case GL_DEBUG_SEVERITY_HIGH:
			s="high";
			break;
		case GL_DEBUG_SEVERITY_MEDIUM:
			s="medium";
			break;
		case GL_DEBUG_SEVERITY_LOW:
			s="low";
			break;
		case GL_DEBUG_SEVERITY_NOTIFICATION:
			s="notification";
			break;
		default:
			s="[UNKNOWN SEVERITY]";
	}

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x826b, %eax           # imm = 0x826B
je 0x8251
jmp 0x8206
movl -0x14(%rbp), %eax
subl $0x9146, %eax           # imm = 0x9146
je 0x822a
jmp 0x8212
movl -0x14(%rbp), %eax
subl $0x9147, %eax           # imm = 0x9147
je 0x8237
jmp 0x821e
movl -0x14(%rbp), %eax
subl $0x9148, %eax           # imm = 0x9148
je 0x8244
jmp 0x825e
leaq 0x222f(%rip), %rax      # 0xa460
movq %rax, -0x10(%rbp)
jmp 0x8269
leaq 0x2227(%rip), %rax      # 0xa465
movq %rax, -0x10(%rbp)
jmp 0x8269
leaq 0x2221(%rip), %rax      # 0xa46c
movq %rax, -0x10(%rbp)
jmp 0x8269
leaq 0x2218(%rip), %rax      # 0xa470
movq %rax, -0x10(%rbp)
jmp 0x8269
leaq 0x2218(%rip), %rax      # 0xa47d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: translateDebugCategoryEnum
static const char *
translateDebugCategoryEnum(GLenum cat)
{
	const char *s;

	switch (cat) {
		case GL_DEBUG_CATEGORY_API_ERROR_AMD:
			s="API error";
			break;
		case GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD:
			s="window system";
			break;
		case GL_DEBUG_CATEGORY_DEPRECATION_AMD:
			s="deprecation";
			break;
		case GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD:
			s="undefined behavior";
			break;
		case GL_DEBUG_CATEGORY_PERFORMANCE_AMD:
			s="performance";
			break;
		case GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD:
			s="shader compiler";
			break;
		case GL_DEBUG_CATEGORY_APPLICATION_AMD:
			s="application";
			break;
		case GL_DEBUG_CATEGORY_OTHER_AMD:
			s="other";
			break;
		default:
			s="[UNKNOWN CATEGORY]";
	}

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0xffff6eb7, %eax       # imm = 0xFFFF6EB7
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x8306
movq -0x18(%rbp), %rax
leaq 0xd9b(%rip), %rcx       # 0x9030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x220e(%rip), %rax      # 0xa4b3
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x211e(%rip), %rax      # 0xa3d0
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x21fe(%rip), %rax      # 0xa4bd
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x215a(%rip), %rax      # 0xa426
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x216c(%rip), %rax      # 0xa445
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x20f8(%rip), %rax      # 0xa3de
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x2105(%rip), %rax      # 0xa3f8
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x2104(%rip), %rax      # 0xa404
movq %rax, -0x10(%rbp)
jmp 0x8311
leaq 0x21bc(%rip), %rax      # 0xa4c9
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: frametimes_finish_frame
static void
frametimes_finish_frame(GH_frametimes *ft)
{
	if (++ft->cur_pos == ft->delay) {
		ft->cur_pos=0;
	}
	++ft->frame;
	if (++ft->cur_result >= ft->num_results) {
		frametimes_flush(ft);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x18(%rcx)
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x87bd
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rcx
movl 0x28(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x28(%rcx)
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x87e9
movq -0x8(%rbp), %rdi
callq 0x77f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3e42
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3e5a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3ea4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x30, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x3e20
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e74
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3f3b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3f11
jmp 0x3f2d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ee4
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: estimate_arc_copy_number_brute_force_impl
static void estimate_arc_copy_number_brute_force_impl(func_t *funcs, int n_func, var_t **vars, int n_var, int *res, int64_t sol_space_size)
{
    double fval, m_fval;
    int64_t sol;
    int a, v;
    fval = fvals(funcs, n_func);
    m_fval = fval;
    copy_results(vars, n_var, res);
    sol = 0;
    while (++sol < sol_space_size) {
        a = 1, v = 0;
        while (a) {
            vars[v] = vars[v]->next;
            a = !vars[v]->B;
            ++v;
        }
        fval = fvals(funcs, n_func);
        if (fval < m_fval) {
            m_fval = fval;
            copy_results(vars, n_var, res);
        }
        if (fabs(m_fval) < FLT_EPSILON)
            break;
    }
#ifdef DEBUG_BRUTE_FORCE_OPTIM
    fprintf(stderr, "[DEBUG_BRUTE_FORCE_OPTIM::%s] brute force search finished after %ld/%ld attempts with a minimum fval: %.6f\n",
            __func__, sol, sol_space_size, m_fval);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13780
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x13930
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
cmpq -0x30(%rbp), %rax
jge 0x5d5e
movl $0x1, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x5cfe
movq -0x18(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x5cb5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13780
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5d39
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x13930
movsd -0x40(%rbp), %xmm1
movaps 0x1d81b(%rip), %xmm0    # 0x23560
pand %xmm0, %xmm1
movsd 0x1d73f(%rip), %xmm0    # 0x23490
ucomisd %xmm1, %xmm0
jbe 0x5d59
jmp 0x5d5e
jmp 0x5c91
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: sequence_duplication_by_copy_number
kh_u32_t *sequence_duplication_by_copy_number(asg_t *asg, int *copy_number, int allow_del)
{
    uint32_t i, n_seg;
    int copy;
    kh_u32_t *seg_dups;
    asmg_t *g;

    n_seg = asg->n_seg;
    g = asg->asmg;
    seg_dups = kh_u32_init();
    for (i = 0; i < n_seg; ++i) {
        if (g->vtx[i].del) continue;
        copy = copy_number[i];
        if (copy > 1) {
            // do copy
            make_seg_dups(asg, seg_dups, i, copy);
#ifdef DEBUG_SEG_COPY
            fprintf(stderr, "[DEBUG_SEG_COPY::%s] make %d extra cop%s of %s [%lu %u]\n", __func__, 
                    copy, copy > 1? "ies" : "y", asg->seg[i].name, g->vtx[i].len, g->vtx[i].cov);
#endif
        } else if (copy == 0 && allow_del) {
            /*** TODO is this safe? **/
            asmg_vtx_del(g, i, 1);
#ifdef DEBUG_SEG_COPY
            fprintf(stderr, "[DEBUG_SEG_COPY::%s] delete seg %s [%lu %u]\n", __func__,
                    asg->seg[i].name, g->vtx[i].len, g->vtx[i].cov);
#endif
        }
    }

#ifdef DEBUG_SEG_COPY
    fprintf(stderr, "[DEBUG_SEG_COPY::%s] graph after expansion\n", __func__);
    asg_print(asg, stderr, 1);
    fprintf(stderr, "[DEBUG_SEG_COPY::%s] expanded graph stats\n", __func__);
    asg_stat(asg, stderr);
#endif
    return seg_dups;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x6030
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x601a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5fc4
jmp 0x600f
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cmpl $0x1, -0x20(%rbp)
jle 0x5fec
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x6040
jmp 0x600d
cmpl $0x0, -0x20(%rbp)
jne 0x600b
cmpl $0x0, -0x14(%rbp)
je 0x600b
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x6640
jmp 0x600d
jmp 0x600f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5f9a
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: new_node
static llnode *new_node(int v) {
    llnode *node;
    MYMALLOC(node, 1);
    node->v = v;
    node->n_m = 4;
    node->n_n = 0;
    node->prev = NULL;
    MYMALLOC(node->next, node->n_m);
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x28, %edi
callq 0x22f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x4, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x22f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x82cd
jmp 0x81e8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x2330
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x82cd
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: rev_array
static inline void rev_array(uint32_t *arr, uint32_t n)
{
    uint32_t tmp, i, j;
    if (n == 0) return;
    for (i = 0, j = n - 1; i < j; ++i, --j) {
        tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x8313
jmp 0x836d
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x836d
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8323
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x84a5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8460
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8474
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: strdup1
static char *strdup1(char *src, uint32_t n)
{
    char *dst;
    MYMALLOC(dst, n+1);
    memcpy(dst, src, n);
    dst[n] = '\0';
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x22f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x22c0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb5e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8c1f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
jmp 0x8c26
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x8c26
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8c3a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x8c52
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x30, %edx
callq 0x22c0
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x30, %edx
callq 0x22c0
movsd -0x28(%rbp), %xmm0
ucomisd -0x58(%rbp), %xmm0
jne 0x8ec7
jp 0x8ec7
jmp 0x8efa
movsd -0x28(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movsd -0x28(%rbp), %xmm0
ucomisd -0x58(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ffb
movl -0x30(%rbp), %eax
cmpl -0x60(%rbp), %eax
je 0x8f29
movl -0x30(%rbp), %eax
cmpl -0x60(%rbp), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
movl -0x30(%rbp), %ecx
cmpl -0x60(%rbp), %ecx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ffb
movl -0x40(%rbp), %eax
shrl $0x1e, %eax
andl $0x1, %eax
movl -0x70(%rbp), %ecx
shrl $0x1e, %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0x8f60
movl -0x40(%rbp), %edx
shrl $0x1e, %edx
andl $0x1, %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ffb
movsd -0x20(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
jne 0x8f70
jp 0x8f70
jmp 0x8fa0
movsd -0x20(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movsd -0x20(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ffb
movl -0x40(%rbp), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl -0x70(%rbp), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
je 0x8ff4
movl -0x40(%rbp), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl -0x70(%rbp), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl -0x40(%rbp), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movl -0x70(%rbp), %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
cmpl %edx, %ecx
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ffb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x90e0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9b70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x90e0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x90b5
movq -0x10(%rbp), %rdi
callq 0x9b70
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x90b3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
subl $0x1, %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
callq 0x9be0
jmp 0x90bf
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: rev_path
static inline void rev_path(path_t *path)
{
    size_t i;
    rev_array(path->v, path->nv);
    for (i = 0; i < path->nv; ++i)
        path->v[i] ^= 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
callq 0x8300
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x9bd9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9b9e
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jbe 0x9c05
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl -0x10(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9c13
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x9c15
jmp 0x9c93
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x9c7e
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x9c5c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
addl -0x18(%rbp), %edx
subl -0x14(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x15eb0
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x9c7c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x15eb0
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x9c24
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x15eb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0xa7c3
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa7c1
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x20(%rbp), %rsi
callq 0x2210
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movslq 0x10(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xa7b4
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2210
jmp 0xa7b6
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa76c
jmp 0xa832
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xa830
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x1fb15(%rip), %rax     # 0x2a300
movsbl (%rax,%rcx), %edi
movq -0x20(%rbp), %rsi
callq 0x2210
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movslq 0x10(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xa823
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2210
jmp 0xa825
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa7cf
jmp 0xa832
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: make_gap
static void make_gap(FILE *fo, uint64_t *l, int line_wd, int gap_size)
{
    int i;
    for (i = 0; i < gap_size; ++i) {
        fputc('N', fo);
        if (++(*l) % line_wd == 0)
            fputc('\n', fo);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa8ab
movq -0x8(%rbp), %rsi
movl $0x4e, %edi
callq 0x2210
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xa89e
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2210
jmp 0xa8a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa85d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb120
jmp 0xb193
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xb193
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0xb183
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
imulq $0x30, -0x20(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
xorl %r8d, %r8d
movl $0x3c, %r9d
movl $0x64, (%rsp)
callq 0xa070
jmp 0xb185
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb128
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_init
asg_t *asg_init()
{
    asg_t *g;
    MYCALLOC(g, 1);
    g->h_seg = kh_sdict_init();
    MYCALLOC(g->asmg, 1);
    return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x28, %esi
callq 0x2240
movq %rax, -0x8(%rbp)
callq 0xb1f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb215
jmp 0xb294
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb24e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x18, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0xb2a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb21d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb273
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb2e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb28b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x17d40
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)