LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_init
rld_t *rld_init(int asize, int bbits)
{
	rld_t *e;
	e = xcalloc(1, sizeof(rld_t));
	e->n = 1;
	e->z = xmalloc(sizeof(void*));
	e->z[0] = xcalloc(RLD_LSIZE, 8);
	e->ssize = 1<<bbits;
	e->cnt = xcalloc(asize + 1, 8);
	e->mcnt = xcalloc(asize + 1, 8);
	e->abits = ilog2(asize) + 1;
	e->asize = asize;
	e->sbits = bbits;
	e->asize1 = asize + 1;
	e->offset0[0] = (e->asize1*16+63)/64;
	e->offset0[1] = (e->asize1*32+63)/64;
	e->offset0[2] = e->asize1;
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x2130
movq %rax, %rbx
movl $0x1, 0xc(%rax)
pushq $0x8
popq %r15
movq %r15, %rdi
callq 0x21a0
movq %rax, %r12
movq %rax, 0x18(%rbx)
movl $0x800000, %edi         # imm = 0x800000
movq %r15, %rsi
callq 0x2130
pushq $0x1
popq %rdx
movl %ebp, %ecx
shll %cl, %edx
movq %rax, (%r12)
movl %edx, 0x8(%rbx)
leal 0x1(%r14), %eax
movslq %eax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, 0x20(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, 0x28(%rbx)
movslq %r14d, %r14
movq %r14, %rdi
callq 0x742b
incb %al
movb %al, 0x2(%rbx)
movb %r14b, (%rbx)
movb %bpl, 0x3(%rbx)
movb %r12b, 0x1(%rbx)
movzbl %r12b, %eax
movl %eax, %ecx
shll $0x4, %ecx
addl $0x3f, %ecx
shrl $0x6, %ecx
movb %cl, 0x5(%rbx)
movl %eax, %ecx
shll $0x5, %ecx
addl $0x3f, %ecx
shrl $0x6, %ecx
movb %cl, 0x6(%rbx)
movb %al, 0x7(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_destroy
void rld_destroy(rld_t *e)
{
	int i = 0;
	if (e == 0) return;
	if (e->mem) {
		close(e->fd);
		munmap(e->mem, rld_file_size(e));
	} else {
		for (i = 0; i < e->n; ++i) free(e->z[i]);
		free(e->frame);
	}
	free(e->z); free(e->cnt); free(e->mcnt); free(e);
}

// Assembly:
testq %rdi, %rdi
je 0x748b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x748c
movl 0x40(%rbx), %edi
callq 0x2110
movq 0x48(%rbx), %rdi
movzbl (%rbx), %eax
leaq (,%rax,8), %rcx
addq 0x10(%rbx), %rcx
incq %rax
imulq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rsi
addq $0x20, %rsi
callq 0x21e0
jmp 0x74b3
retq
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x74aa
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
jmp 0x748f
movq 0x38(%rbx), %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_enc
int rld_enc(rld_t *e, rlditr_t *itr, int64_t l, uint8_t c)
{
	if (l == 0) return 0;
	if (itr->c != c) {
		if (itr->l) rld_enc1(e, itr, itr->l, itr->c);
		itr->l = l; itr->c = c;
	} else itr->l += l;
	return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x7596
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl 0x4(%rsi), %eax
movzbl %cl, %ebp
movq 0x8(%rsi), %rdx
cmpl %ebp, %eax
jne 0x757b
addq %r14, %rdx
movq %rdx, 0x8(%rbx)
jmp 0x7592
testq %rdx, %rdx
je 0x758b
movzbl %al, %ecx
movq %rbx, %rsi
callq 0x7599
movq %r14, 0x8(%rbx)
movl %ebp, 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_enc1
static int rld_enc1(rld_t *e, rlditr_t *itr, int64_t l, uint8_t c)
{
	int w;
	uint64_t x = rld_delta_enc1(l, &w) << e->abits | c;
	w += e->abits;
	if (w >= itr->r && itr->p == itr->stail) enc_next_block(e, itr);
	if (w > itr->r) {
		w -= itr->r;
		*itr->p++ |= x >> w;
		*itr->p = x << (itr->r = 64 - w);
	} else itr->r -= w, *itr->p |= x << itr->r;
	e->cnt[0] += l;
	e->cnt[c + 1] += l;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x742b
movslq %eax, %r12
leaq 0x1(%r12), %r13
leal 0x1(%r12), %edi
callq 0x87fd
movq %r14, %rdi
leal (%r12,%rax,2), %r14d
incl %r14d
movl %r12d, %ecx
shlq %cl, %r13
movq %rbx, %rax
btcq %r12, %rax
orq %rax, %r13
movsbl 0x2(%rdi), %ecx
shlq %cl, %r13
movl %ebp, %r12d
addl %ecx, %r14d
movl (%r15), %eax
cmpl %eax, %r14d
jl 0x7613
movq 0x10(%r15), %rcx
cmpq 0x20(%r15), %rcx
jne 0x7613
movq %rdi, %rbp
movq %r15, %rsi
callq 0x79b1
movq %rbp, %rdi
movl (%r15), %eax
orq %r12, %r13
movl %r14d, %ecx
movq 0x10(%r15), %rdx
subl %eax, %ecx
jle 0x7642
movq %r13, %rax
shrq %cl, %rax
leaq 0x8(%rdx), %rsi
movq %rsi, 0x10(%r15)
orq %rax, (%rdx)
pushq $0x40
popq %rax
subl %ecx, %eax
negl %ecx
shlq %cl, %r13
movq %r13, 0x8(%rdx)
jmp 0x764d
subl %r14d, %eax
movl %eax, %ecx
shlq %cl, %r13
orq %r13, (%rdx)
movl %eax, (%r15)
movq 0x20(%rdi), %rax
addq %rbx, (%rax)
addq %rbx, 0x8(%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_enc_finish
uint64_t rld_enc_finish(rld_t *e, rlditr_t *itr)
{
	int i;
	if (itr->l) rld_enc1(e, itr, itr->l, itr->c);
	enc_next_block(e, itr);
	e->n_bytes = (((uint64_t)(e->n - 1) * RLD_LSIZE) + (itr->p - *itr->i)) * 8;
	// recompute e->cnt as the accumulative count; e->mcnt[] keeps the marginal counts
	for (e->cnt[0] = 0, i = 1; i <= e->asize; ++i) e->cnt[i] += e->cnt[i - 1];
	rld_rank_index(e);
	return e->n_bytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x7955
movzbl 0x4(%r14), %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7599
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79b1
movslq 0xc(%rbx), %rax
shlq $0x1a, %rax
movq 0x28(%r14), %rcx
addq 0x10(%r14), %rax
subq (%rcx), %rax
addq $-0x4000000, %rax       # imm = 0xFC000000
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rax
andq $0x0, (%rax)
movzbl (%rbx), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x799d
movq (%rax,%rdx,8), %rsi
addq %rsi, 0x8(%rax,%rdx,8)
incq %rdx
jmp 0x798a
movq %rbx, %rdi
callq 0x766b
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: enc_next_block
static inline void enc_next_block(rld_t *e, rlditr_t *itr)
{
	int i, type;
	if (itr->stail + 2 - *itr->i == RLD_LSIZE) {
		++e->n;
		e->z = realloc(e->z, e->n * sizeof(void*));
		itr->i = e->z + e->n - 1;
		itr->shead = *itr->i = xcalloc(RLD_LSIZE, 8);
	} else itr->shead += e->ssize;
	if (e->cnt[0] - e->mcnt[0] < 0x4000) {
		uint16_t *p = (uint16_t*)itr->shead;
		for (i = 0; i <= e->asize; ++i) p[i] = e->cnt[i] - e->mcnt[i];
		type = 0;
	} else if (e->cnt[0] - e->mcnt[0] < 0x40000000) {
		uint32_t *p = (uint32_t*)itr->shead;
		for (i = 0; i <= e->asize; ++i) p[i] = e->cnt[i] - e->mcnt[i];
		type = 1;
	} else {
		uint64_t *p = (uint64_t*)itr->shead;
		for (i = 0; i <= e->asize; ++i) p[i] = e->cnt[i] - e->mcnt[i];
		type = 2;
	}
	*itr->shead |= (uint64_t)type<<62;
	itr->p = itr->shead + e->offset0[type];
	itr->stail = rld_get_stail(e, itr);
	itr->q = (uint8_t*)itr->p;
	itr->r = 64;
	for (i = 0; i <= e->asize; ++i) e->mcnt[i] = e->cnt[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %r15
subq (%r15), %rax
cmpq $0x3fffff0, %rax        # imm = 0x3FFFFF0
jne 0x7a12
movslq 0xc(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0xc(%r14)
movq 0x18(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x21c0
movq %rax, 0x18(%r14)
movslq 0xc(%r14), %rcx
leaq (%rax,%rcx,8), %r15
addq $-0x8, %r15
movq %r15, 0x28(%rbx)
pushq $0x8
popq %rsi
movl $0x800000, %edi         # imm = 0x800000
callq 0x2130
movq %rax, (%r15)
jmp 0x7a1e
movslq 0x8(%r14), %rax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
movq (%rcx), %rdi
subq (%rdx), %rdi
cmpq $0x3fff, %rdi           # imm = 0x3FFF
ja 0x7a5c
movzbl (%r14), %esi
incq %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x7aa1
movl (%rcx,%r8,8), %r9d
subl (%rdx,%r8,8), %r9d
movw %r9w, (%rax,%r8,2)
incq %r8
jmp 0x7a45
movzbl (%r14), %esi
incq %rsi
xorl %r8d, %r8d
cmpq $0x40000000, %rdi       # imm = 0x40000000
jae 0x7a88
pushq $0x1
popq %rdi
cmpq %r8, %rsi
je 0x7aa1
movl (%rcx,%r8,8), %r9d
subl (%rdx,%r8,8), %r9d
movl %r9d, (%rax,%r8,4)
incq %r8
jmp 0x7a72
pushq $0x2
popq %rdi
cmpq %r8, %rsi
je 0x7aa1
movq (%rcx,%r8,8), %r9
subq (%rdx,%r8,8), %r9
movq %r9, (%rax,%r8,8)
incq %r8
jmp 0x7a8b
movq %rdi, %r8
shlq $0x3e, %r8
orq %r8, (%rax)
movsbq 0x5(%r14,%rdi), %rdi
leaq (%rax,%rdi,8), %rdi
movq %rdi, 0x10(%rbx)
movslq 0x8(%r14), %r8
leaq (%rax,%r8,8), %rax
movq %rax, %r8
subq (%r15), %r8
xorl %r9d, %r9d
cmpq $0x4000000, %r8         # imm = 0x4000000
setne %r9b
shll $0x3, %r9d
orq $-0x10, %r9
addq %rax, %r9
movq %r9, 0x20(%rbx)
movq %rdi, 0x30(%rbx)
movl $0x40, (%rbx)
xorl %eax, %eax
cmpq %rax, %rsi
je 0x7b02
movq (%rcx,%rax,8), %rdi
movq %rdi, (%rdx,%rax,8)
incq %rax
jmp 0x7af0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_dump
int rld_dump(const rld_t *e, const char *fn)
{
	uint64_t k = 0;
	int i;
	uint32_t a;
	FILE *fp;
	fp = strcmp(fn, "-")? fopen(fn, "wb") : fdopen(fileno(stdout), "wb");
	if (fp == 0) return -1;
	a = e->asize<<16 | e->sbits;
	fwrite("RLD\3", 1, 4, fp); // write magic
	fwrite(&a, 4, 1, fp); // write sbits and asize
	fwrite(&k, 8, 1, fp); // preserve 8 bytes for future uses
	fwrite(&e->n_bytes, 8, 1, fp); // n_bytes can always be divided by 8
	fwrite(&e->n_frames, 8, 1, fp); // number of frames
	fwrite(e->mcnt + 1, 8, e->asize, fp); // write the marginal counts
	for (i = 0, k = e->n_bytes / 8; i < e->n - 1; ++i, k -= RLD_LSIZE)
		fwrite(e->z[i], 8, RLD_LSIZE, fp);
	fwrite(e->z[i], 8, k, fp);
	fwrite(e->frame, 8 * e->asize1, e->n_frames, fp);
	fclose(fp);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
andq $0x0, (%rsp)
movq %rdi, %rbx
cmpb $0x2d, (%rsi)
jne 0x7b2c
cmpb $0x0, 0x1(%rsi)
je 0x7c5c
leaq 0xcc46(%rip), %rax      # 0x14779
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
je 0x7c4b
movzbl (%rbx), %eax
shll $0x10, %eax
movsbl 0x3(%rbx), %ecx
orl %eax, %ecx
leaq 0xc(%rsp), %r15
movl %ecx, (%r15)
leaq 0xcc17(%rip), %rdi      # 0x1477c
pushq $0x1
popq %r12
pushq $0x4
popq %r13
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x2260
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2260
movq %rsp, %rdi
pushq $0x8
popq %r15
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2260
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2260
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2260
movq 0x28(%rbx), %rdi
addq $0x8, %rdi
movzbl (%rbx), %edx
movq %r15, %rsi
movq %r14, %rcx
callq 0x2260
movq 0x10(%rbx), %r12
shrq $0x3, %r12
xorl %r13d, %r13d
movslq 0xc(%rbx), %rcx
decq %rcx
movq 0x18(%rbx), %rax
cmpq %rcx, %r13
jge 0x7c16
movq (%rax,%r13,8), %rdi
movl $0x800000, %edx         # imm = 0x800000
movq %r15, %rsi
movq %r14, %rcx
callq 0x2260
incq %r13
addq $-0x800000, %r12        # imm = 0xFF800000
jmp 0x7be6
movq (%rax,%r13,8), %rdi
pushq $0x8
popq %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2260
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rdi
movzbl 0x1(%rbx), %esi
shll $0x3, %esi
movq %r14, %rcx
callq 0x2260
movq %r14, %rdi
callq 0x2090
xorl %eax, %eax
jmp 0x7c4e
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1335d(%rip), %rax     # 0x1afc0
movq (%rax), %rdi
callq 0x2180
leaq 0xcb07(%rip), %rsi      # 0x14779
movl %eax, %edi
callq 0x21d0
jmp 0x7b3e
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_restore_header
static rld_t *rld_restore_header(const char *fn, FILE **_fp)
{
	FILE *fp;
	rld_t *e;
	char magic[4];
	uint64_t a[3];
	int32_t i, x;

	if (strcmp(fn, "-") == 0) *_fp = fp = stdin;
	else if ((*_fp = fp = fopen(fn, "rb")) == 0) return 0;
	fread(magic, 1, 4, fp);
	if (strncmp(magic, "RLD\3", 4)) return 0;
	fread(&x, 4, 1, fp);
	e = rld_init(x>>16, x&0xffff);
	fread(a, 8, 3, fp);
	e->n_bytes = a[1]; e->n_frames = a[2];
	fread(e->mcnt + 1, 8, e->asize, fp);
	for (i = 0; i <= e->asize; ++i) e->cnt[i] = e->mcnt[i];
	for (i = 1; i <= e->asize; ++i) e->cnt[i] += e->cnt[i - 1];
	e->mcnt[0] = e->cnt[e->asize];
	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
cmpb $0x2d, (%rdi)
jne 0x7f12
cmpb $0x0, 0x1(%rdi)
je 0x7f2b
leaq 0xc868(%rip), %rsi      # 0x14781
callq 0x2230
movq %rax, %r14
movq %rax, (%rbx)
testq %rax, %rax
jne 0x7f38
jmp 0x7f56
movq 0x13096(%rip), %rax     # 0x1afc8
movq (%rax), %r14
movq %r14, (%rbx)
leaq 0xc(%rsp), %rbx
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2060
cmpl $0x3444c52, (%rbx)      # imm = 0x3444C52
je 0x7f5d
xorl %ebx, %ebx
jmp 0x8001
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2060
movl (%rbx), %edi
movzwl %di, %esi
sarl $0x10, %edi
callq 0x736c
movq %rax, %rbx
leaq 0x10(%rsp), %r15
pushq $0x8
popq %r12
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x2060
movq 0x8(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rbx)
movq 0x28(%rbx), %r13
leaq 0x8(%r13), %rdi
movzbl (%rbx), %r15d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2060
movq 0x20(%rbx), %rax
leaq 0x1(%r15), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x7fe4
movq (%r13,%rdx,8), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
jmp 0x7fd1
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x7ff9
movq (%rax,%rcx,8), %rdx
addq %rdx, 0x8(%rax,%rcx,8)
incq %rcx
jmp 0x7fe6
movq (%rax,%r15,8), %rax
movq %rax, (%r13)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_restore_mmap
rld_t *rld_restore_mmap(const char *fn)
{
	FILE *fp;
	rld_t *e;
	int i;
	int64_t n_blks;

	e = rld_restore_header(fn, &fp);
	fclose(fp);
	free(e->z[0]); free(e->z);
	e->n = (e->n_bytes / 8 + RLD_LSIZE - 1) / RLD_LSIZE;
	e->z = xcalloc(e->n, sizeof(void*));
	e->fd = open(fn, O_RDONLY);
	e->mem = (uint64_t*)mmap(0, rld_file_size(e), PROT_READ, MAP_PRIVATE, e->fd, 0);
	for (i = 0; i < e->n; ++i) e->z[i] = e->mem + (4 + e->asize) + (size_t)i * RLD_LSIZE;
	e->frame = e->mem + (4 + e->asize) + e->n_bytes/8;
	n_blks = e->n_bytes * 8 / 64 / e->ssize + 1;
	e->ibits = ilog2(e->mcnt[0] / n_blks) + RLD_IBITS_PLUS;
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x7ef7
movq %rax, %rbx
movq (%r14), %rdi
callq 0x2090
movq 0x18(%rbx), %r14
movq (%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movq 0x10(%rbx), %r13
movq %r13, %r15
shrq $0x3, %r15
leaq 0x7fffff(%r15), %rax
shrq $0x17, %rax
movl %eax, 0xc(%rbx)
movslq %eax, %rdi
movq %rdi, (%rsp)
pushq $0x8
popq %rsi
callq 0x2130
movq %rax, %r14
movq %rax, 0x18(%rbx)
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2220
movl %eax, 0x40(%rbx)
movzbl (%rbx), %ecx
movl %ecx, %r12d
shll $0x3, %r12d
addq %r12, %r13
movq %rcx, 0x8(%rsp)
incq %rcx
imulq 0x30(%rbx), %rcx
leaq 0x20(,%rcx,8), %rsi
addq %r13, %rsi
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x20b0
movq %rax, 0x48(%rbx)
leaq (%rax,%r12), %rcx
addq $0x20, %rcx
movq (%rsp), %rsi
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
cmpq %rbp, %rdx
je 0x80f6
movq %rcx, (%r14,%rbp,8)
incq %rbp
addq $0x4000000, %rcx        # imm = 0x4000000
jmp 0x80e1
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx,8), %rax
leaq (%rax,%r15,8), %rax
addq $0x20, %rax
movq %rax, 0x38(%rbx)
movabsq $0x3ffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFF
andq %r15, %rax
movslq 0x8(%rbx), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
incq %rcx
movq 0x28(%rbx), %rax
movq (%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
callq 0x742b
addb $0x4, %al
movb %al, 0x4(%rbx)
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_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_rank11
uint64_t rld_rank11(const rld_t *e, uint64_t k, int c)
{
	uint64_t *ok;
	if (k == (uint64_t)-1) return 0;
	ok = alloca(e->asize1 * 8);
	rld_rank1a(e, k, ok);
	return ok[c];
}

// Assembly:
cmpq $-0x1, %rsi
je 0x81c9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movzbl 0x1(%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
movq %r14, %rdx
callq 0x81cc
movslq %ebx, %rax
movq (%r14,%rax,8), %rax
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_rank1a
int rld_rank1a(const rld_t *e, uint64_t k, uint64_t *ok)
{
	uint64_t z, l;
	int a = -1;
	rlditr_t itr;
	if (k == 0) {
		for (a = 0; a < e->asize; ++a) ok[a] = 0;
		return -1;
	}
	rld_locate_blk(e, &itr, k-1, ok, &z);
	while (1) {
#ifdef _DNA_ONLY
		l = rld_dec0_fast_dna(e, &itr, &a);
#else
		l = rld_dec0(e, &itr, &a);
#endif
		if (z + l >= k) break;
		z += l; ok[a] += l;
	}
	ok[a] += k - z;
	return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
orl $-0x1, 0xc(%rsp)
testq %rsi, %rsi
je 0x824a
movq %rsi, %r14
leaq -0x1(%rsi), %rdx
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r15, %rsi
movq %rbx, %rcx
movq %r12, %r8
callq 0x8261
movq (%r12), %r13
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x846b
leaq (%rax,%r13), %rcx
cmpq %r14, %rcx
jae 0x8230
movslq 0xc(%rsp), %rdx
addq %rax, (%rbx,%rdx,8)
movq %rcx, %r13
jmp 0x820e
subq %r13, %r14
movslq 0xc(%rsp), %rax
addq %r14, (%rbx,%rax,8)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movzbl (%rdi), %ecx
xorl %edx, %edx
pushq $-0x1
popq %rax
cmpq %rdx, %rcx
je 0x823c
andq $0x0, (%rbx,%rdx,8)
incq %rdx
jmp 0x8252
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/rld0.c
// Function: rld_dec0_fast_dna
static inline int64_t rld_dec0_fast_dna(const rld_t *e, rlditr_t *itr, int *c)
{ // This is NOT a replacement of rld_dec0(). It does not do boundary check.
	uint64_t x = itr->r == 64? itr->p[0] : itr->p[0] << (64 - itr->r) | itr->p[1] >> itr->r;
	if (x>>63 == 0) {
		int64_t y;
		int l, w = 0x333333335555779bll>>(x>>59<<2)&0xf;
		l = (x >> (64 - w)) - 1;
		y = x << w >> (64 - l) | 1u << l;
		w += l;
		*c = x << w >> 61;
		w += 3;
		itr->r -= w;
		if (itr->r <= 0) ++itr->p, itr->r += 64;
		return y;
	} else {
		*c = x << 1 >> 61;
		itr->r -= 4;
		if (itr->r <= 0) ++itr->p, itr->r += 64;
		return 1;
	}
}

// Assembly:
movl (%rdi), %ecx
movq 0x10(%rdi), %rdx
movq (%rdx), %r8
cmpq $0x40, %rcx
je 0x8485
movq 0x8(%rdx), %rax
shrdq %cl, %r8, %rax
movq %rax, %r8
testq %r8, %r8
js 0x84ef
movq %r8, %rcx
shrq $0x39, %rcx
andb $0x3c, %cl
movabsq $0x333333335555779b, %rax # imm = 0x333333335555779B
shrq %cl, %rax
movl %eax, %r9d
andl $0xf, %r9d
movl %r9d, %ecx
negb %cl
movq %r8, %r10
shrq %cl, %r10
andb $0xf, %al
movq %r8, %r11
movl %eax, %ecx
shlq %cl, %r11
movb $0x41, %cl
subb %r10b, %cl
shrq %cl, %r11
leal -0x1(%r10), %ecx
pushq $0x1
popq %rax
shll %cl, %eax
leal (%r10,%r9), %ecx
decl %ecx
shlq %cl, %r8
orq %r11, %rax
shrq $0x3d, %r8
movl %r8d, (%rsi)
movl (%rdi), %esi
subl %ecx, %esi
leal -0x3(%rsi), %ecx
movl %ecx, (%rdi)
testl %ecx, %ecx
jle 0x8516
retq
shrq $0x3c, %r8
andl $0x7, %r8d
movl %r8d, (%rsi)
movl (%rdi), %esi
leal -0x4(%rsi), %eax
movl %eax, (%rdi)
cmpl $0x4, %esi
jg 0x8524
addq $0x8, %rdx
movq %rdx, 0x10(%rdi)
addl $0x3c, %esi
pushq $0x1
popq %rax
jmp 0x8521
addq $0x8, %rdx
movq %rdx, 0x10(%rdi)
addl $0x3d, %esi
movl %esi, (%rdi)
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/unitig.c
// Function: fm6_retrieve
uint64_t fm6_retrieve(const rld_t *e, uint64_t x, kstring_t *s, rldintv_t *k2, int *contained)
{
	uint64_t k = x, ok[6];
	rldintv_t ok2[6];
	s->l = 0; *contained = 0;
	while (1) {
		int c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) break;
		if (s->l > 0) {
			if (k2->x[2] == 1) k2->x[0] = k;
			else {
				rld_extend(e, k2, ok2, 1);
				*k2 = ok2[c];
			}
		} else fm6_set_intv(e, c, *k2);
		kputc(c, s);
	}
	if (k2->x[2] != 1) {
		rld_extend(e, k2, ok2, 1);
		if (ok2[0].x[2] != k2->x[2]) *contained |= 1; // left contained
		*k2 = ok2[0];
	} else k2->x[0] = k;
	rld_extend(e, k2, ok2, 0);
	if (ok2[0].x[2] != k2->x[2]) *contained |= 2; // right contained
	*k2 = ok2[0];
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %rbx
movq %rsi, %r14
movq %rdx, 0x18(%rsp)
andq $0x0, (%rdx)
movq %rdi, 0x8(%rsp)
movq %r8, 0x10(%rsp)
andl $0x0, (%r8)
incq %r14
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
leaq 0xe0(%rsp), %rdx
callq 0x81cc
movl %eax, %r13d
movq 0x20(%r15), %rax
movslq %r13d, %r12
movq (%rax,%r12,8), %r15
movq 0xe0(%rsp,%r12,8), %r14
leaq (%r14,%r15), %rbp
decq %rbp
testl %r12d, %r12d
je 0x89c2
movq 0x18(%rsp), %rcx
cmpq $0x0, (%rcx)
je 0x8951
cmpq $0x1, 0x10(%rbx)
jne 0x8981
movq %rbp, (%rbx)
jmp 0x89ad
leal -0x5(%r13), %ecx
negl %ecx
cmpl $0x5, %r13d
movq %r15, (%rbx)
movq 0x8(%rax,%r12,8), %rdx
cmovael %r13d, %ecx
subq (%rax,%r12,8), %rdx
movq %rdx, 0x10(%rbx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
jmp 0x89ad
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x873b
shlq $0x5, %r12
movups 0x20(%rsp,%r12), %xmm0
movups 0x30(%rsp,%r12), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
addq %r15, %r14
movl %r13d, %edi
movq 0x18(%rsp), %rsi
callq 0x8a58
jmp 0x88fc
cmpq $0x1, 0x10(%rbx)
jne 0x89ce
movq %rbp, (%rbx)
jmp 0x8a09
leaq 0x20(%rsp), %r14
pushq $0x1
popq %rcx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x873b
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
je 0x89f8
movq 0x10(%rsp), %rax
orb $0x1, (%rax)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %r14
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x873b
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
je 0x8a32
movq 0x10(%rsp), %rax
orb $0x2, (%rax)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbp, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/unitig.c
// Function: fm6_is_contained
int fm6_is_contained(const rld_t *e, int min_match, const kstring_t *s, rldintv_t *intv, rldintv_v *ovlp)
{ // for s is a sequence in e, test if s is contained in other sequences in e; return intervals right overlapping with s
	rldintv_t ik, ok[6];
	int ret = 0;
	assert(s->l > min_match);
	ovlp->n = 0;
	ik = overlap_intv(e, s->l, (uint8_t*)s->s, min_match, s->l - 1, 0, ovlp, 0);
	rld_extend(e, &ik, ok, 1); assert(ok[0].x[2]);
	if (ik.x[2] != ok[0].x[2]) ret = -1; // the sequence is left contained
	ik = ok[0];
	rld_extend(e, &ik, ok, 0); assert(ok[0].x[2]);
	if (ik.x[2] != ok[0].x[2]) ret = -1; // the sequence is right contained
	*intv = ok[0];
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %r8, %rax
movq %rcx, %rbx
movq %rdx, %rcx
movl %esi, %r8d
movq (%rdx), %rdx
movslq %esi, %rsi
cmpq %rsi, %rdx
jbe 0x97ad
movq %rdi, %r14
andq $0x0, (%rax)
movq 0x10(%rcx), %rcx
leal -0x1(%rdx), %r9d
subq $0x8, %rsp
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
pushq $0x0
pushq %rax
pushq $0x0
callq 0x980a
addq $0x20, %rsp
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movq %rsp, %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x873b
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x97cc
movq %rsp, %rsi
movq 0x10(%rsi), %r13
leaq 0x20(%rsp), %r15
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps %xmm0, (%rsi)
movaps %xmm1, 0x10(%rsi)
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x873b
movq 0x10(%r15), %rcx
testq %rcx, %rcx
je 0x97eb
xorq %r12, %r13
xorq 0x10(%rsp), %rcx
xorl %eax, %eax
orq %r13, %rcx
setne %al
negl %eax
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb0dc(%rip), %rdi      # 0x14890
leaq 0xb0e6(%rip), %rsi      # 0x148a1
leaq 0xb0e8(%rip), %rcx      # 0x148aa
movl $0x80, %edx
callq 0x20e0
leaq 0xb12d(%rip), %rdi      # 0x14900
leaq 0xb0c7(%rip), %rsi      # 0x148a1
leaq 0xb0c9(%rip), %rcx      # 0x148aa
movl $0x83, %edx
callq 0x20e0
leaq 0xb10e(%rip), %rdi      # 0x14900
leaq 0xb0a8(%rip), %rsi      # 0x148a1
leaq 0xb0aa(%rip), %rcx      # 0x148aa
movl $0x86, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/unitig.c
// Function: set_bits
static inline void set_bits(uint64_t *bits, const rldintv_t *p)
{
	uint64_t k;
	for (k = 0; k < p->x[2]; ++k) {
		set_bit(bits, p->x[0] + k);
		set_bit(bits, p->x[1] + k);
	}
}

// Assembly:
xorl %eax, %eax
pushq $0x1
popq %rdx
cmpq 0x10(%rsi), %rax
jae 0xa1ee
movq (%rsi), %rcx
addq %rax, %rcx
movq %rcx, %r8
shrq $0x6, %r8
movq %rdx, %r9
shlq %cl, %r9
lock
orq %r9, (%rdi,%r8,8)
movq 0x8(%rsi), %rcx
addq %rax, %rcx
movq %rcx, %r8
shrq $0x6, %r8
movq %rdx, %r9
shlq %cl, %r9
lock
orq %r9, (%rdi,%r8,8)
incq %rax
jmp 0xa1b2
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/unitig.c
// Function: copy_nei
static void copy_nei(ku128_v *dst, const rldintv_v *src)
{
	int i;
	for (i = 0; i < src->n; ++i) {
		ku128_t z;
		z.x = src->a[i].x[0]; z.y = src->a[i].info;
		kv_push(ku128_t, *dst, z);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %r13, (%rbx)
jbe 0xaf6d
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rbp
movq 0x18(%rax,%r15), %r12
movq (%r14), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rcx
jne 0xaf50
leaq (%rcx,%rcx), %rsi
testq %rcx, %rcx
pushq $0x2
popq %rcx
cmoveq %rcx, %rsi
movq %rsi, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, 0x10(%r14)
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
shlq $0x4, %rcx
movq %rbp, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
incq %r13
addq $0x20, %r15
jmp 0xaf0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: v128_clean
static inline void v128_clean(ku128_v *r)
{
	int i, j;
	for (i = j = 0; i < r->n; ++i)
		if (!edge_is_del(r->a[i])) { // keep this arc
			if (j != i) r->a[j++] = r->a[i];
			else ++j;
		}
	r->n = j;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movslq %edx, %rsi
cmpq %rcx, (%rdi)
jbe 0xd018
movq 0x10(%rdi), %r8
cmpq $-0x2, (%r8,%rax)
je 0xd00f
cmpq $0x0, 0x8(%r8,%rax)
je 0xd00f
movl %edx, %r9d
incl %edx
cmpq %r9, %rcx
je 0xd00f
leaq (%r8,%rax), %r9
shlq $0x4, %rsi
movups (%r9), %xmm0
movups %xmm0, (%r8,%rsi)
incq %rcx
addq $0x10, %rax
jmp 0xcfd9
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_g_build_hash
void mag_g_build_hash(mag_t *g)
{
	long i;
	int j, ret;
	hash64_t *h;
	h = kh_init(64);
	for (i = 0; i < g->v.n; ++i) {
		const magv_t *p = &g->v.a[i];
		for (j = 0; j < 2; ++j) {
			khint_t k = kh_put(64, h, p->k[j], &ret);
			if (ret == 0) {
				if (fm_verbose >= 2)
					fprintf(stderr, "[W::%s] terminal %ld is duplicated.\n", __func__, (long)p->k[j]);
				kh_val(h, k) = (uint64_t)-1;
			} else kh_val(h, k) = i<<1|j;
		}
	}
	g->h = h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
pushq $0x10
popq %r13
callq 0xafb0
movq %rax, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movq %r12, 0x8(%rsp)
cmpq (%r12), %r15
jae 0xd0e0
movq 0x10(%r12), %r12
movq %r13, 0x10(%rsp)
addq %r13, %r12
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0xd0c6
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
leaq 0x4(%rsp), %rdx
callq 0xb2d5
movl %eax, %ebp
cmpl $0x0, 0x4(%rsp)
je 0xd083
leaq (%rbx,%r13), %rax
jmp 0xd08f
cmpl $0x2, 0xe1e6(%rip)      # 0x1b270
pushq $-0x1
popq %rax
jge 0xd09e
movq 0x20(%r14), %rcx
movl %ebp, %edx
movq %rax, (%rcx,%rdx,8)
incq %r13
jmp 0xd05d
movq 0xdf53(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
movq (%r12,%r13,8), %rcx
leaq 0x7a2d(%rip), %rsi      # 0x14ae0
leaq 0x7a4b(%rip), %rdx      # 0x14b05
xorl %eax, %eax
callq 0x2150
pushq $-0x1
popq %rax
jmp 0xd08f
incq %r15
movq 0x10(%rsp), %r13
addq $0x68, %r13
addq $0x2, %rbx
movq 0x8(%rsp), %r12
jmp 0xd043
movq %r14, 0x20(%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_g_amend
void mag_g_amend(mag_t *g)
{
	int i, j, l, ll;
	for (i = 0; i < g->v.n; ++i) {
		magv_t *p = &g->v.a[i];
		ku128_v *r;
		for (j = 0; j < 2; ++j) {
			for (l = 0; l < p->nei[j].n; ++l) {
				khint_t k;
				uint64_t z, x = p->nei[j].a[l].x;
				k = kh_get(64, g->h, x);
				if (k == kh_end((hash64_t*)g->h)) { // neighbor is not in the hash table; likely due to tip removal
					edge_mark_del(p->nei[j].a[l]);
					continue;
				} else z = kh_val((hash64_t*)g->h, k);
				r = &g->v.a[z>>1].nei[z&1];
				for (ll = 0, z = p->k[j]; ll < r->n; ++ll)
					if (r->a[ll].x == z) break;
				if (ll == r->n) // not in neighbor's neighor
					edge_mark_del(p->nei[j].a[l]);
			}
			v128_rmdup(&p->nei[j]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
cmpq %rcx, (%rbx)
jbe 0xd257
movq 0x10(%rbx), %rax
movq %rcx, 0x10(%rsp)
imulq $0x68, %rcx, %rcx
leaq (%rax,%rcx), %rdx
movq %rdx, 0x20(%rsp)
addq %rcx, %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x2, %rax
je 0xd24a
movq %rax, (%rsp)
imulq $0x18, %rax, %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx,%rax), %rbp
xorl %r14d, %r14d
cmpq %rbp, %r14
je 0xd234
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r12
movq %r14, %r13
shlq $0x4, %r13
movq (%r12,%r13), %rsi
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0xb01f
cmpl (%r15), %eax
jne 0xd1d7
leaq (%r12,%r13), %rax
movq $-0x2, (%rax)
andq $0x0, 0x8(%r12,%r13)
incq %r14
jmp 0xd193
movq 0x20(%r15), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
imulq $0x68, %rcx, %rcx
addq 0x10(%rbx), %rcx
imulq $0x18, %rax, %rax
addq %rcx, %rax
addq $0x20, %rax
movq 0x20(%rsp), %rcx
movq (%rsp), %rdx
movq 0x10(%rcx,%rdx,8), %rdx
movq (%rax), %rcx
incq %rcx
xorl %esi, %esi
cmpq $0x1, %rcx
je 0xd1c1
movq 0x10(%rax), %rdi
decq %rcx
leaq 0x10(%rsi), %r8
cmpq %rdx, (%rdi,%rsi)
movq %r8, %rsi
jne 0xd213
testq %rcx, %rcx
jne 0xd1d2
jmp 0xd1c1
movq 0x8(%rsp), %rdi
callq 0xd266
movq (%rsp), %rax
incq %rax
jmp 0xd16c
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0xd13f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: v128_rmdup
static inline void v128_rmdup(ku128_v *r)
{
	int l, cnt;
	uint64_t x;
	if (r->n > 1) ks_introsort(128x, r->n, r->a);
	for (l = cnt = 0; l < r->n; ++l) // jump to the first node to be retained
		if (edge_is_del(r->a[l])) ++cnt;
		else break;
	if (l == r->n) { // no good arcs
		r->n = 0;
		return;
	}
	x = r->a[l].x;
	for (++l; l < r->n; ++l) { // mark duplicated node
		if (edge_is_del(r->a[l]) || r->a[l].x == x)
			edge_mark_del(r->a[l]), ++cnt;
		else x = r->a[l].x;
	}
	if (cnt) v128_clean(r);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq $0x2, %rdi
jb 0xd27f
movq 0x10(%rbx), %rsi
callq 0xb9a1
movq (%rbx), %rdi
pushq $0x8
popq %rcx
xorl %eax, %eax
cmpq %rax, %rdi
je 0xd2a5
movq 0x10(%rbx), %rdx
cmpq $-0x2, -0x8(%rdx,%rcx)
je 0xd29c
cmpq $0x0, (%rdx,%rcx)
jne 0xd2a8
incq %rax
addq $0x10, %rcx
jmp 0xd284
movq %rdi, %rax
cmpq %rax, %rdi
jne 0xd2b3
andq $0x0, (%rbx)
jmp 0xd322
movq 0x10(%rbx), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rdx
movl %eax, %esi
addq $0x18, %rcx
movq %rsi, %r11
shlq $0x4, %r11
addq %rcx, %r11
movq %rsi, %r8
movq %rdx, %r10
movq %r8, %rsi
incq %r8
cmpq %r8, %rdi
jbe 0xd315
movq %r10, %rdx
movq %r11, %r9
movq -0x8(%r11), %r10
cmpq $-0x2, %r10
je 0xd302
cmpq $0x0, (%r9)
je 0xd302
leaq 0x10(%r9), %r11
cmpq %rdx, %r10
jne 0xd2d8
movq $-0x2, -0x8(%r9)
andq $0x0, (%r9)
incl %eax
incq %rsi
jmp 0xd2c8
testl %eax, %eax
je 0xd322
movq %rbx, %rdi
popq %rbx
jmp 0xcfd3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_g_print
void mag_g_print(const mag_t *g)
{
	int i;
	kstring_t out;
	out.l = out.m = 0; out.s = 0;
	for (i = 0; i < g->v.n; ++i) {
		if (g->v.a[i].len < 0) continue;
		mag_v_write(&g->v.a[i], &out);
		fwrite(out.s, 1, out.l, stdout);
	}
	free(out.s);
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %ebp, %ebp
pushq $0x1
popq %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, (%rbx)
jbe 0xd862
movq 0x10(%rbx), %rdi
cmpl $0x0, (%rdi,%rbp)
js 0xd859
addq %rbp, %rdi
movq %r14, %rsi
callq 0xd324
movq (%rsp), %rdx
movq 0x10(%rsp), %r12
movq 0xd775(%rip), %rax      # 0x1afc0
movq (%rax), %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2260
incq %r13
addq $0x68, %rbp
jmp 0xd821
movq %r12, %rdi
callq 0x2040
movq 0xd74f(%rip), %rax      # 0x1afc0
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_v_destroy
void mag_v_destroy(magv_t *v)
{
	free(v->nei[0].a); free(v->nei[1].a);
	free(v->seq); free(v->cov);
	memset(v, 0, sizeof(magv_t));
	v->len = -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x2040
movq 0x48(%rbx), %rdi
callq 0x2040
movq 0x50(%rbx), %rdi
callq 0x2040
movq 0x58(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x60(%rbx)
movups %xmm0, 0x10(%rbx)
orl $-0x1, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_g_destroy
void mag_g_destroy(mag_t *g)
{
	int i;
	kh_destroy(64, g->h);
	for (i = 0; i < g->v.n; ++i)
		mag_v_destroy(&g->v.a[i]);
	free(g->v.a);
	free(g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xafbb
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
cmpq %r15, (%rbx)
jbe 0xd904
addq %r14, %rdi
callq 0xd887
incq %r15
addq $0x68, %r14
jmp 0xd8ea
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_v_copy_to_empty
void mag_v_copy_to_empty(magv_t *dst, const magv_t *src) // NB: memory leak if dst is allocated
{
	memcpy(dst, src, sizeof(magv_t));
	dst->max_len = dst->len + 1;
	kroundup32(dst->max_len);
	dst->seq = calloc(dst->max_len, 1); memcpy(dst->seq, src->seq, src->len);
	dst->cov = calloc(dst->max_len, 1); memcpy(dst->cov, src->cov, src->len);
	kv_init(dst->nei[0]); kv_copy(ku128_t, dst->nei[0], src->nei[0]);
	kv_init(dst->nei[1]); kv_copy(ku128_t, dst->nei[1], src->nei[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0xd
popq %rcx
rep  movsq (%rsi), %es:(%rdi)
movl (%r14), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %r15d
shrl $0x10, %r15d
orl %eax, %r15d
incl %r15d
movl %r15d, 0x8(%r14)
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, 0x50(%r14)
movq 0x50(%rbx), %rsi
movslq (%rbx), %r13
movq %rax, %rdi
movq %r13, %rdx
callq 0x2170
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, 0x58(%r14)
movq 0x58(%rbx), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0x2170
andq $0x0, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0xda01
leaq -0x1(%r15), %rax
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, %rdi
shrq $0x10, %rdi
orq %rax, %rdi
incq %rdi
movq %rdi, 0x28(%r14)
shlq $0x4, %rdi
callq 0x21a0
movq %rax, %rdi
movq %rax, 0x30(%r14)
jmp 0xda03
xorl %edi, %edi
movq %r15, 0x20(%r14)
movq 0x20(%rbx), %rdx
movq 0x30(%rbx), %rsi
shlq $0x4, %rdx
callq 0x2170
andq $0x0, 0x48(%r14)
leaq 0x38(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq 0x38(%rbx), %r12
testq %r12, %r12
je 0xda81
leaq -0x1(%r12), %rax
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, %rdi
shrq $0x10, %rdi
orq %rax, %rdi
incq %rdi
movq %rdi, 0x40(%r14)
shlq $0x4, %rdi
callq 0x21a0
movq %rax, %rdi
movq %rax, 0x48(%r14)
jmp 0xda83
xorl %edi, %edi
movq %r12, (%r15)
movq 0x38(%rbx), %rdx
movq 0x48(%rbx), %rsi
shlq $0x4, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_eh_add
void mag_eh_add(mag_t *g, uint64_t u, uint64_t v, int ovlp) // add v to u
{
	ku128_v *r;
	ku128_t *q;
	uint64_t idd;
	int i;
	if ((int64_t)u < 0) return;
	idd = tid2idd(g->h, u);
	r = &g->v.a[idd>>1].nei[idd&1];
	for (i = 0; i < r->n; ++i) // no multi-edges
		if (r->a[i].x == v) return;
	kv_pushp(ku128_t, *r, &q);
	q->x = v; q->y = ovlp;
}

// Assembly:
testq %rsi, %rsi
js 0xdb4a
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xd0f6
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
imulq $0x68, %rcx, %rcx
addq 0x10(%r15), %rcx
imulq $0x18, %rax, %rax
leaq (%rax,%rcx), %r15
addq $0x20, %r15
movq (%r15), %rcx
pushq $-0x1
popq %rax
xorl %edx, %edx
incq %rax
cmpq %rax, %rcx
je 0xdaff
leaq 0x10(%rdx), %rsi
movq 0x10(%r15), %rdi
cmpq %r14, (%rdi,%rdx)
movq %rsi, %rdx
jne 0xdae4
jmp 0xdb45
movq 0x10(%r15), %rax
cmpq 0x8(%r15), %rcx
jne 0xdb2e
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
pushq $0x2
popq %rsi
cmovneq %rdx, %rsi
movq %rsi, 0x8(%r15)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, 0x10(%r15)
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movslq %ebx, %rdx
movq %rdx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_eh_markdel
void mag_eh_markdel(mag_t *g, uint64_t u, uint64_t v) // mark deletion of v from u
{
	int i;	
	uint64_t idd;
	if ((int64_t)u < 0) return;
	idd = tid2idd(g->h, u);
	ku128_v *r = &g->v.a[idd>>1].nei[idd&1];
	for (i = 0; i < r->n; ++i)
		if (r->a[i].x == v) edge_mark_del(r->a[i]);
}

// Assembly:
testq %rsi, %rsi
js 0xdbaf
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xd0f6
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
imulq $0x68, %rcx, %rcx
addq 0x10(%r14), %rcx
imulq $0x18, %rax, %rax
addq %rcx, %rax
addq $0x20, %rax
movq (%rax), %rcx
xorl %edx, %edx
subq $0x1, %rcx
jb 0xdba8
movq 0x10(%rax), %rsi
cmpq %rbx, (%rsi,%rdx)
jne 0xdba2
movq $-0x2, (%rsi,%rdx)
andq $0x0, 0x8(%rsi,%rdx)
addq $0x10, %rdx
jmp 0xdb84
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_v_del
void mag_v_del(mag_t *g, magv_t *p)
{
	int i, j;
	khint_t k;
	if (p->len < 0) return;
	for (i = 0; i < 2; ++i) {
		ku128_v *r = &p->nei[i];
		for (j = 0; j < r->n; ++j)
			if (!edge_is_del(r->a[j]) && r->a[j].x != p->k[0] && r->a[j].x != p->k[1])
				mag_eh_markdel(g, r->a[j].x, p->k[i]);
	}
	for (i = 0; i < 2; ++i) {
		k = kh_get(64, g->h, p->k[i]);
		kh_del(64, g->h, k);
	}
	mag_v_destroy(p);
}

// Assembly:
cmpl $0x0, (%rsi)
js 0xdc6c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0xdc2d
imulq $0x18, %r12, %rbp
addq (%rsp), %rbp
pushq $0x8
popq %r13
xorl %r15d, %r15d
cmpq %r15, (%rbp)
jbe 0xdc28
movq 0x10(%rbp), %rax
movq -0x8(%rax,%r13), %rsi
cmpq $-0x2, %rsi
je 0xdc1f
cmpq $0x0, (%rax,%r13)
je 0xdc1f
cmpq 0x10(%rbx), %rsi
je 0xdc1f
cmpq 0x18(%rbx), %rsi
je 0xdc1f
movq 0x10(%rbx,%r12,8), %rdx
movq %r14, %rdi
callq 0xdb4b
incq %r15
addq $0x10, %r13
jmp 0xdbea
incq %r12
jmp 0xdbd5
pushq $0x2
popq %r12
cmpq $0x4, %r12
je 0xdc56
movq 0x20(%r14), %r15
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0xb01f
movq %r15, %rdi
movl %eax, %esi
callq 0xb467
incq %r12
jmp 0xdc31
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd887
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_v_transdel
void mag_v_transdel(mag_t *g, magv_t *p, int min_ovlp)
{
	if (p->nei[0].n && p->nei[1].n) {
		int i, j, ovlp;
		for (i = 0; i < p->nei[0].n; ++i) {
			if (edge_is_del(p->nei[0].a[i]) || p->nei[0].a[i].x == p->k[0] || p->nei[0].a[i].x == p->k[1]) continue; // due to p->p loop
			for (j = 0; j < p->nei[1].n; ++j) {
				if (edge_is_del(p->nei[1].a[j]) || p->nei[1].a[j].x == p->k[0] || p->nei[1].a[j].x == p->k[1]) continue;
				ovlp = (int)(p->nei[0].a[i].y + p->nei[1].a[j].y) - p->len;
				if (ovlp >= min_ovlp) {
					mag_eh_add(g, p->nei[0].a[i].x, p->nei[1].a[j].x, ovlp);
					mag_eh_add(g, p->nei[1].a[j].x, p->nei[0].a[i].x, ovlp);
				}
			}
		}
	}
	mag_v_del(g, p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0x20(%rsi), %rcx
testq %rcx, %rcx
je 0xdd78
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xdd78
movl %edx, %r8d
xorl %r12d, %r12d
movl %edx, 0x14(%rsp)
cmpq %r12, %rcx
jbe 0xdd78
movq 0x30(%rbx), %rsi
movq %r12, %r13
shlq $0x4, %r13
movq (%rsi,%r13), %rdx
cmpq $-0x2, %rdx
je 0xdd70
addq %r13, %rsi
cmpq $0x0, 0x8(%rsi)
je 0xdd70
cmpq 0x10(%rbx), %rdx
je 0xdd70
cmpq 0x18(%rbx), %rdx
je 0xdd70
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpq %r14, %rax
jbe 0xdd6c
movq 0x48(%rbx), %rcx
movq (%rcx,%rbp), %rdx
cmpq $-0x2, %rdx
je 0xdd63
movq 0x8(%rcx,%rbp), %r15
testq %r15, %r15
je 0xdd63
cmpq 0x10(%rbx), %rdx
je 0xdd63
cmpq 0x18(%rbx), %rdx
je 0xdd63
movq 0x30(%rbx), %rcx
addl 0x8(%rcx,%r13), %r15d
subl (%rbx), %r15d
cmpl %r8d, %r15d
jl 0xdd63
addq %r13, %rcx
movq (%rcx), %rsi
movq 0x8(%rsp), %rdi
movl %r15d, %ecx
callq 0xdaa0
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
movq (%rcx,%rbp), %rsi
movq (%rax,%r13), %rdx
movq 0x8(%rsp), %rdi
movl %r15d, %ecx
callq 0xdaa0
movl 0x14(%rsp), %r8d
movq 0x38(%rbx), %rax
incq %r14
addq $0x10, %rbp
jmp 0xdcf0
movq 0x20(%rbx), %rcx
incq %r12
jmp 0xdca7
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdbb0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_v_flip
void mag_v_flip(mag_t *g, magv_t *p)
{
	ku128_v t;
	khint_t k;
	hash64_t *h = (hash64_t*)g->h;

	seq_revcomp6(p->len, (uint8_t*)p->seq);
	seq_reverse(p->len, (uint8_t*)p->cov);
	p->k[0] ^= p->k[1]; p->k[1] ^= p->k[0]; p->k[0] ^= p->k[1];
	t = p->nei[0]; p->nei[0] = p->nei[1]; p->nei[1] = t;
	k = kh_get(64, h, p->k[0]);
	assert(k != kh_end(h));
	kh_val(h, k) ^= 1;
	k = kh_get(64, h, p->k[1]);
	assert(k != kh_end(h));
	kh_val(h, k) ^= 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x20(%rdi), %rbx
movl (%rsi), %edi
movq 0x50(%rsi), %rsi
callq 0x37be
movl (%r14), %edi
movq 0x58(%r14), %rsi
callq 0x3796
movq 0x10(%r14), %rax
movq 0x18(%r14), %rsi
movq %rax, 0x18(%r14)
movq %rsi, 0x10(%r14)
movq 0x30(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%r14), %xmm0
movaps %xmm0, (%rsp)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x20(%r14)
movq 0x48(%r14), %rax
movq %rax, 0x30(%r14)
movaps (%rsp), %xmm0
movups %xmm0, 0x38(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%r14)
movq %rbx, %rdi
callq 0xb01f
movl (%rbx), %ebp
cmpl %ebp, %eax
je 0xde3c
movq 0x20(%rbx), %r15
movl %eax, %eax
xorq $0x1, (%r15,%rax,8)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xb01f
cmpl %ebp, %eax
je 0xde5b
movl %eax, %eax
xorb $0x1, (%r15,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x657c(%rip), %rdi      # 0x143bf
leaq 0x6cd1(%rip), %rsi      # 0x14b1b
leaq 0x6cd0(%rip), %rcx      # 0x14b21
movl $0x12b, %edx            # imm = 0x12B
callq 0x20e0
leaq 0x655d(%rip), %rdi      # 0x143bf
leaq 0x6cb2(%rip), %rsi      # 0x14b1b
leaq 0x6cb1(%rip), %rcx      # 0x14b21
movl $0x12e, %edx            # imm = 0x12E
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mag.c
// Function: mag_g_merge
void mag_g_merge(mag_t *g, int rmdup, int min_merge_len)
{
	int i;
	uint64_t n = 0;
	for (i = 0; i < g->v.n; ++i) { // remove multiedges; FIXME: should we do that?
		if (rmdup) {
			v128_rmdup(&g->v.a[i].nei[0]);
			v128_rmdup(&g->v.a[i].nei[1]);
		} else {
			v128_clean(&g->v.a[i].nei[0]);
			v128_clean(&g->v.a[i].nei[1]);
		}
	}
	for (i = 0; i < g->v.n; ++i) {
		magv_t *p = &g->v.a[i];
		if (p->len < 0) continue;
		while (mag_vh_merge_try(g, p, min_merge_len) == 0) ++n;
		mag_v_flip(g, p);
		while (mag_vh_merge_try(g, p, min_merge_len) == 0) ++n;
	}
	if (fm_verbose >= 3)
		fprintf(stderr, "[M::%s] unambiguously merged %ld pairs of vertices\n", __func__, (long)n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x38
popq %r15
xorl %r12d, %r12d
movq (%r14), %rax
cmpq %r12, %rax
jbe 0xe228
movq 0x10(%r14), %rax
leaq (%rax,%r15), %rdi
addq $-0x18, %rdi
testl %ebp, %ebp
je 0xe20e
callq 0xd266
movq 0x10(%r14), %rdi
addq %r15, %rdi
callq 0xd266
jmp 0xe21f
callq 0xcfd3
movq 0x10(%r14), %rdi
addq %r15, %rdi
callq 0xcfd3
incq %r12
addq $0x68, %r15
jmp 0xe1e3
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r13, %rax
jbe 0xe28a
movq 0x10(%r14), %r12
imulq $0x68, %r13, %rcx
cmpl $0x0, (%r12,%rcx)
js 0xe285
addq %rcx, %r12
decq %r15
movq %r15, %rcx
movq %rcx, %r15
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xde7a
leaq 0x1(%r15), %rcx
testl %eax, %eax
je 0xe24b
movq %r14, %rdi
movq %r12, %rsi
callq 0xdd93
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xde7a
incq %r15
testl %eax, %eax
je 0xe26e
movq (%r14), %rax
incq %r13
jmp 0xe22e
cmpl $0x3, 0xcfdf(%rip)      # 0x1b270
jge 0xe2a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xcd4f(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x6995(%rip), %rsi      # 0x14c48
leaq 0x69c2(%rip), %rdx      # 0x14c7c
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150