LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: output_filename
static unsigned int
output_filename(struct compress_args * const args)
{
	unsigned int len;
	int ret = 0;

	if (args->compress) {
		len = sizeof(args->filename_out);
		strncpy(args->filename_out, args->filename, len);
		args->filename_out[len - 1 - sizeof(SUFFIX)] = '\0';
		strcat(args->filename_out, SUFFIX);
	} else {
		len = strlen(args->filename);
		if (len < sizeof(SUFFIX)) {
			ret = EINVAL;
			fprintf(stderr, "File %s: unknown file type\n",
			    args->filename);
			goto out;
		}

		len -= sizeof(SUFFIX) - 1;
		if (strcmp(&args->filename[len], SUFFIX) != 0) {
			ret = EINVAL;
			fprintf(stderr, "File %s: unknown file type\n",
			    args->filename);
			goto out;
		}

		strncpy(args->filename_out, args->filename,
		    sizeof(args->filename_out));
		if (len >= sizeof(args->filename_out))
			len = sizeof(args->filename_out) - 1;
		args->filename_out[len] = '\0';
	}
 out:
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1010(%rax)
je 0x345f
movl $0x1000, -0xc(%rbp)     # imm = 0x1000
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x1060
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
subq $0x5, %rcx
movb $0x0, 0x10(%rax,%rcx)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0x4378(%rip), %rsi      # 0x77cd
callq 0x1220
jmp 0x352e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x5, %rax
jae 0x34a4
movl $0x16, -0x10(%rbp)
movq 0x6b72(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x433a(%rip), %rsi      # 0x77d2
movb $0x0, %al
callq 0x1190
jmp 0x3530
movl -0xc(%rbp), %eax
subq $0x4, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %eax
addq %rax, %rdi
leaq 0x430a(%rip), %rsi      # 0x77cd
callq 0x1170
cmpl $0x0, %eax
je 0x34f6
movl $0x16, -0x10(%rbp)
movq 0x6b1d(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x42e5(%rip), %rsi      # 0x77d2
movb $0x0, %al
callq 0x1190
jmp 0x3530
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1060
movl -0xc(%rbp), %eax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x3522
movl $0xfff, -0xc(%rbp)      # imm = 0xFFF
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0x10(%rax,%rcx)
jmp 0x3530
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode_none
static unsigned int
lzm_encode_none(
    const struct lzm_state * const state,
    const unsigned char * const buffer_in,
    const unsigned int size_in,
    unsigned char * const buffer_out,
    unsigned int * const size_out)
{
	unsigned char *curr_out;

	(void)state;

	curr_out = output_literals(buffer_out, buffer_in, size_in,
	    buffer_out + *size_out);
	if (curr_out == NULL)
		return EOVERFLOW;

	*size_out = curr_out - buffer_out;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movl (%rax), %eax
addq %rax, %rcx
callq 0x4e80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x406c
movl $0x4b, -0x4(%rbp)
jmp 0x4086
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_malloc
static int
lzm_malloc(void **addr, unsigned int size)
{
	int error;

	error = posix_memalign(addr, MEM_ALIGN, size);
	if (error != 0)
		error = ENOMEM;

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %edx
movl $0x40, %esi
callq 0x1240
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x4d42
movl $0xc, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode_finish
unsigned int
lzm_encode_finish(const struct lzm_state * const state)
{
	if (state != NULL) {
		if (state->last_ht != NULL)
			free(state->last_ht);
		if (state->chains != NULL)
			free(state->chains);
		free((void *)state);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d9a
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4d79
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d91
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode
unsigned int
lzm_encode(const struct lzm_state * const state,
    const unsigned char * const buffer_in,
    const unsigned int size_in, unsigned char * const buffer_out,
    unsigned int * const size_out)
{
	int error;

	if (buffer_in == NULL || buffer_out == NULL)
		return EINVAL;

	if (size_in <= 16) {
		error = lzm_encode_none(state, buffer_in, size_in,
		    buffer_out, size_out);
	} else {
		error = lzm_encode_config[state->level].codec(state,
		    buffer_in, size_in, buffer_out, size_out);

		if (error == EOVERFLOW && state->level != LZM_LEVEL_NONE)
			error = lzm_encode_none(state, buffer_in, size_in,
			    buffer_out, size_out);
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4dd9
cmpq $0x0, -0x28(%rbp)
jne 0x4de5
movl $0x16, -0x4(%rbp)
jmp 0x4e6d
cmpl $0x10, -0x1c(%rbp)
ja 0x4e08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x4020
movl %eax, -0x34(%rbp)
jmp 0x4e67
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
leaq 0x53a8(%rip), %rax      # 0xa1c0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x4b, -0x34(%rbp)
jne 0x4e65
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x4e65
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x4020
movl %eax, -0x34(%rbp)
jmp 0x4e67
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_data
static inline unsigned char *
output_data(unsigned char *out, const unsigned char * const start,
    const unsigned int literals, const unsigned int offset,
    const unsigned int length)
{
	unsigned char * const op = out++;

	*op = 0;
	out = output_offset(out, offset);
	out = output_literals_op(op, out, start, literals);
	out = output_match_op(op, out, length);

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4f60
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x4fe0
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5070
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_offset
static inline unsigned char *
output_offset(unsigned char * const out, const unsigned int length)
{
	const struct offset_map * const map =
	    &offmap[__builtin_clz(length | !length)];
	const unsigned int bytes = map->bytes;
	const unsigned int prefix = map->prefix;

	writemem32(out, (length << bytes) | prefix);

	return out + bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl $0x0, -0xc(%rbp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
bsrl %eax, %eax
xorl $0x1f, %eax
movslq %eax, %rcx
leaq 0x286c(%rip), %rax      # 0x7800
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %ecx
shll %cl, %esi
orl -0x20(%rbp), %esi
callq 0x50d0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_literals_op
static inline unsigned char *
output_literals_op(unsigned char * const op, unsigned char *out,
    const unsigned char * const start, const unsigned int length)
{
	if (length > 0) {
		if (length < 15) {
			*op = length << 4;
			memcpy(out, start, 16);
		} else {
			*op = 15 << 4;
			out = output_length(out, length - 15);
			memcpy(out, start, length);
		}
		out += length;
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x5065
cmpl $0xf, -0x1c(%rbp)
jae 0x5029
movl -0x1c(%rbp), %eax
shll $0x4, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5055
movq -0x8(%rbp), %rax
movb $-0x10, (%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0xf, %esi
callq 0x50f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x11b0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_match_op
static inline unsigned char *
output_match_op(unsigned char * const op, unsigned char *out,
    const unsigned int length)
{
	if (length < 15) {
		*op |= length;
	} else {
		*op |= 15;
		out = output_length(out, length - 15);
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0xf, -0x14(%rbp)
jae 0x5099
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x50b8
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
orl $0xf, %ecx
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0xf, %esi
callq 0x50f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_length
static inline unsigned char *
output_length(unsigned char *out, const unsigned int length)
{
	if (likely(length < 252)) {
		*out++ = length;
	} else if (likely(length < (256+252))) {
		*out++ = 252;
		*out++ = length - 252;
	} else if (likely(length < (65536+253))) {
		*out++ = 253;
		writemem16(out, length - 253);
		out += 2;
	} else if (likely(length < (16777216+254))) {
		*out++ = 254;
		writemem32(out, length - 254);
		out += 3;
	} else {
		*out++ = 255;
		writemem32(out, length - 255);
		out += 4;
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xfc, -0xc(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5131
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x5244
cmpl $0x1fc, -0xc(%rbp)      # imm = 0x1FC
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x517a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x4, (%rax)
movl -0xc(%rbp), %eax
subl $0xfc, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x5242
cmpl $0x100fd, -0xc(%rbp)    # imm = 0x100FD
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x51c5
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x3, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0xfd, %eax
movzwl %ax, %esi
callq 0x5250
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x5240
cmpl $0x10000fe, -0xc(%rbp)  # imm = 0x10000FE
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x520e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x2, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0xfe, %esi
callq 0x50d0
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x523e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x1, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0xff, %esi
callq 0x50d0
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x5240
jmp 0x5242
jmp 0x5244
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_reset
static inline void
lzm_reset(const struct lzm_state * const state,
    const unsigned char * const buffer_in)
{
	struct ht_entry ht;
	unsigned int i;

	ht.index = 0;
	ht.token = readmem32(buffer_in);

	for (i = 0; i < state->hash_buckets; i++)
		state->last_ht[i] = ht;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5920
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x52c3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x529a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_match_merge
static inline unsigned char *
output_match_merge(struct prev_match * const prev, unsigned char *out,
    const unsigned char * const start, const unsigned char * const last,
    const unsigned int length, const unsigned char * const out_limit)
{
	if (likely(prev->length > 0)) {
		if (prev->start + prev->length <= start) {
			out = output_match_last(prev, out, out_limit);
		} else {
			if ((prev->start + MIN_MATCH) <= start) {
				prev->length = start - prev->start;
				out = output_match_last(prev, out, out_limit);
			}
		}
	}

	prev->start = start;
	prev->last = last;
	prev->length = length;

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5caa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
ja 0x5c67
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5d70
movq %rax, -0x10(%rbp)
jmp 0x5ca8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x4, %rax
cmpq -0x18(%rbp), %rax
ja 0x5ca6
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5d70
movq %rax, -0x10(%rbp)
jmp 0x5ca8
jmp 0x5caa
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_match_final
static inline unsigned char *
output_match_final(struct prev_match * const prev, unsigned char *out,
    const unsigned char * const end, const unsigned char * const out_limit)
{
	if (likely(prev->length > 0)) {
		out = output_match_last(prev, out, out_limit);
		if (out == NULL)
			return NULL;
	}

	return output_literals(out, prev->lit_start, end - prev->lit_start,
	    out_limit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5d38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5d70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d36
movq $0x0, -0x8(%rbp)
jmp 0x5d60
jmp 0x5d38
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x28(%rbp), %rcx
callq 0x4e80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmencode.c
// Function: output_match_last
static inline unsigned char *
output_match_last(struct prev_match * const prev, unsigned char *out,
    const unsigned char * const out_limit)
{
	out = output_match(out, prev->lit_start,
	    prev->start - prev->lit_start, prev->start - prev->last,
	    prev->length, out_limit);
	prev->lit_start = prev->start + prev->length;

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r8d
movq -0x18(%rbp), %r9
callq 0x58b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmdecode.c
// Function: decode_offset
static inline const unsigned char *
decode_offset(const unsigned char * const in, unsigned int * const length)
{
	const unsigned int len = readmem32(in);
	const unsigned int bytes = __builtin_ctz(len) + 1;

	*length = (len & mask[bytes]) >> bytes;

	return in + bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
tzcntl %eax, %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
leaq 0x1148(%rip), %rcx      # 0x7900
andl (%rcx,%rdx,4), %eax
movl -0x18(%rbp), %ecx
shrl %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzmdecode.c
// Function: decode_length
static inline const unsigned char *
decode_length(const unsigned char *in, unsigned int * const length)
{
	unsigned int len;

	len = *in++;
	if (likely(len < 252)) {
		;
	} else if (likely(len == 252)) {
		len += *in;
		in += 1;
	} else if (likely(len == 253)) {
		len += readmem16(in);
		in += 2;
	} else if (likely(len == 254)) {
		len += readmem32(in) & 0xFFFFFF;
		in += 3;
	} else {
		len += readmem32(in);
		in += 4;
	}

	*length = len;
	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xfc, -0x14(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6821
jmp 0x68e7
cmpl $0xfc, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6856
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x68e5
cmpl $0xfd, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x688d
movq -0x8(%rbp), %rdi
callq 0x6900
movzwl %ax, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x68e3
cmpl $0xfe, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x68c6
movq -0x8(%rbp), %rdi
callq 0x6940
andl $0xffffff, %eax         # imm = 0xFFFFFF
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x68e1
movq -0x8(%rbp), %rdi
callq 0x6940
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x68e3
jmp 0x68e5
jmp 0x68e7
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: km_init2
void *km_init2(void *km_par, size_t min_core_size)
{
	kmem_t *km;
	km = (kmem_t*)kcalloc(km_par, 1, sizeof(kmem_t));
	km->par = km_par;
	if (km_par) km->min_core_size = min_core_size > 0? min_core_size : ((kmem_t*)km_par)->min_core_size - 2;
	else km->min_core_size = min_core_size > 0? min_core_size : 0x80000;
	return (void*)km;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x30, %edx
callq 0x2540
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x2508
cmpq $0x0, -0x10(%rbp)
jbe 0x24ea
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x24fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2530
cmpq $0x0, -0x10(%rbp)
jbe 0x2519
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2524
movl $0x80000, %eax          # imm = 0x80000
movq %rax, -0x28(%rbp)
jmp 0x2524
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: kcalloc
void *kcalloc(void *_km, size_t count, size_t size)
{
	kmem_t *km = (kmem_t*)_km;
	void *p;
	if (size == 0 || count == 0) return 0;
	if (km == NULL) return calloc(count, size);
	p = kmalloc(km, count * size);
	memset(p, 0, count * size);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x256a
cmpq $0x0, -0x18(%rbp)
jne 0x2574
movq $0x0, -0x8(%rbp)
jmp 0x25c0
cmpq $0x0, -0x28(%rbp)
jne 0x258e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21e0
movq %rax, -0x8(%rbp)
jmp 0x25c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x2890
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x2190
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: km_destroy
void km_destroy(void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	void *km_par;
	header_t *p, *q;
	if (km == NULL) return;
	km_par = km->par;
	for (p = km->core_head; p != NULL;) {
		q = p->ptr;
		kfree(km_par, p);
		p = q;
	}
	kfree(km_par, km);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x260d
jmp 0x265b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x264e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2670
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2624
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2670
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: kmalloc
void *kmalloc(void *_km, size_t n_bytes)
{
	kmem_t *km = (kmem_t*)_km;
	size_t n_units;
	header_t *p, *q;

	if (n_bytes == 0) return 0;
	if (km == NULL) return malloc(n_bytes);
	n_units = (n_bytes + sizeof(size_t) + sizeof(header_t) - 1) / sizeof(header_t); /* header+n_bytes requires at least this number of units */

	if (!(q = km->loop_head)) /* the first time when kmalloc() is called, intialize it */
		q = km->loop_head = km->base.ptr = &km->base;
	for (p = q->ptr;; q = p, p = p->ptr) { /* search for a suitable block */
		if (p->size >= n_units) { /* p->size if the size of current block. This line means the current block is large enough. */
			if (p->size == n_units) q->ptr = p->ptr; /* no need to split the block */
			else { /* split the block. NB: memory is allocated at the end of the block! */
				p->size -= n_units; /* reduce the size of the free block */
				p += p->size; /* p points to the allocated block */
				*(size_t*)p = n_units; /* set the size */
			}
			km->loop_head = q; /* set the end of chain */
			return (size_t*)p + 1;
		}
		if (p == km->loop_head) { /* then ask for more "cores" */
			if ((p = morecore(km, n_units)) == 0) return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x28bc
movq $0x0, -0x8(%rbp)
jmp 0x29e8
cmpq $0x0, -0x20(%rbp)
jne 0x28d5
movq -0x18(%rbp), %rdi
callq 0x2280
movq %rax, -0x8(%rbp)
jmp 0x29e8
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rax
subq $0x1, %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x291b
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jb 0x299c
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x2953
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2982
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
shlq $0x4, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x29e8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x29cd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2a00
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x29cb
movq $0x0, -0x8(%rbp)
jmp 0x29e8
jmp 0x29cd
jmp 0x29cf
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2927
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: morecore
static header_t *morecore(kmem_t *km, size_t nu)
{
	header_t *q;
	size_t bytes, *p;
	nu = (nu + 1 + (km->min_core_size - 1)) / km->min_core_size * km->min_core_size; /* the first +1 for core header */
	bytes = nu * sizeof(header_t);
	q = (header_t*)kmalloc(km->par, bytes);
	if (!q) panic("[morecore] insufficient memory");
	q->ptr = km->core_head, q->size = nu, km->core_head = q;
	p = (size_t*)(q + 1);
	*p = nu - 1; /* the size of the free block; -1 because the first unit is used for the core header */
	kfree(km, p + 1); /* initialize the new "core"; NB: the core header is not looped. */
	return km->loop_head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2890
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a71
leaq 0x39691(%rip), %rdi     # 0x3c0fd
callq 0x2860
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq 0x2670
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: krealloc
void *krealloc(void *_km, void *ap, size_t n_bytes) // TODO: this can be made more efficient in principle
{
	kmem_t *km = (kmem_t*)_km;
	size_t cap, *p, *q;

	if (n_bytes == 0) {
		kfree(km, ap); return 0;
	}
	if (km == NULL) return realloc(ap, n_bytes);
	if (ap == NULL) return kmalloc(km, n_bytes);
	p = (size_t*)ap - 1;
	cap = (*p) * sizeof(header_t) - sizeof(size_t);
	if (cap >= n_bytes) return ap; /* TODO: this prevents shrinking */
	q = (size_t*)kmalloc(km, n_bytes);
	memcpy(q, ap, cap);
	kfree(km, ap);
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2b1d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2670
movq $0x0, -0x8(%rbp)
jmp 0x2bbe
cmpq $0x0, -0x28(%rbp)
jne 0x2b3a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22b0
movq %rax, -0x8(%rbp)
jmp 0x2bbe
cmpq $0x0, -0x18(%rbp)
jne 0x2b54
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2890
movq %rax, -0x8(%rbp)
jmp 0x2bbe
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
shlq $0x4, %rax
subq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x2b87
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2bbe
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2890
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2230
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2670
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: krelocate
void *krelocate(void *km, void *ap, size_t n_bytes)
{
	void *p;
	if (km == 0 || ap == 0) return ap;
	p = kmalloc(km, n_bytes);
	memcpy(p, ap, n_bytes);
	kfree(km, ap);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bf2
cmpq $0x0, -0x18(%rbp)
jne 0x2bfc
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c33
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2230
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2670
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: km_stat
void km_stat(const void *_km, km_stat_t *s)
{
	kmem_t *km = (kmem_t*)_km;
	header_t *p;
	memset(s, 0, sizeof(km_stat_t));
	if (km == NULL || km->loop_head == NULL) return;
	for (p = km->loop_head;; p = p->ptr) {
		s->available += p->size * sizeof(header_t);
		if (p->size != 0) ++s->n_blocks; /* &kmem_t::base is always one of the cores. It is zero-sized. */
		if (p->ptr > p && p + p->size > p->ptr)
			panic("[km_stat] The end of a free block enters another free block.");
		if (p->ptr == km->loop_head) break;
	}
	for (p = km->core_head; p != NULL; p = p->ptr) {
		size_t size = p->size * sizeof(header_t);
		++s->n_cores;
		s->capacity += size;
		s->largest = s->largest > size? s->largest : size;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2190
cmpq $0x0, -0x18(%rbp)
je 0x2c7a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2c7f
jmp 0x2d97
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
shlq $0x4, %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2cbc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x2cf2
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2cf2
leaq 0x3938f(%rip), %rdi     # 0x3c07c
callq 0x2860
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x2d06
jmp 0x2d19
jmp 0x2d08
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2c8b
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2d97
movq -0x20(%rbp), %rax
movq (%rax), %rax
shlq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0x2d75
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2d7d
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d25
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kalloc.c
// Function: km_stat_print
void km_stat_print(const void *km)
{
	km_stat_t st;
	km_stat(km, &st);
	fprintf(stderr, "[km_stat] cap=%ld, avail=%ld, largest=%ld, n_core=%ld, n_block=%ld\n",
			st.capacity, st.available, st.largest, st.n_blocks, st.n_cores);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2c40
movq 0x42238(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
leaq 0x392db(%rip), %rsi     # 0x3c0b9
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2210
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kthread.c
// Function: kt_for
void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
{
	if (n_threads > 1) {
		int i;
		kt_for_t t;
		pthread_t *tid;
		t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
		t.w = (ktf_worker_t*)calloc(n_threads, sizeof(ktf_worker_t));
		tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
		for (i = 0; i < n_threads; ++i)
			t.w[i].t = &t, t.w[i].i = i;
		for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
		for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
		free(tid); free(t.w);
	} else {
		long j;
		for (j = 0; j < n; ++j) func(data, j, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x4(%rbp)
jle 0x2f25
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x10, %esi
callq 0x21e0
movq %rax, -0x40(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x21e0
movq %rax, -0x58(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2e9a
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
leaq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movslq -0x24(%rbp), %rcx
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2e5a
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2ee2
movq -0x58(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x8e(%rip), %rdx        # 0x2f60
callq 0x22c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ea1
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2f11
movq -0x58(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ee9
movq -0x58(%rbp), %rdi
callq 0x2040
movq -0x40(%rbp), %rdi
callq 0x2040
jmp 0x2f57
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x2f55
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f2d
jmp 0x2f57
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/kthread.c
// Function: kt_pipeline
void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps)
{
	ktp_t aux;
	pthread_t *tid;
	int i;

	if (n_threads < 1) n_threads = 1;
	aux.n_workers = n_threads;
	aux.n_steps = n_steps;
	aux.func = func;
	aux.shared = shared_data;
	aux.index = 0;
	pthread_mutex_init(&aux.mutex, 0);
	pthread_cond_init(&aux.cv, 0);

	aux.workers = (ktp_worker_t*)calloc(n_threads, sizeof(ktp_worker_t));
	for (i = 0; i < n_threads; ++i) {
		ktp_worker_t *w = &aux.workers[i];
		w->step = 0; w->pl = &aux; w->data = 0;
		w->index = aux.index++;
	}

	tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktp_worker, &aux.workers[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
	free(tid); free(aux.workers);

	pthread_mutex_destroy(&aux.mutex);
	pthread_cond_destroy(&aux.cv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x3056
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x90(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2370
leaq -0xa0(%rbp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2240
movslq -0x4(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x80(%rbp)
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3153
movq -0x80(%rbp), %rax
movslq -0xac(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0xb8(%rbp), %rax
leaq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xb8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x90(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0xb8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x30cd
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x21e0
movq %rax, -0xa8(%rbp)
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x31c5
movq -0xa8(%rbp), %rdi
movslq -0xac(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x80(%rbp), %rcx
movslq -0xac(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0xa1(%rip), %rdx        # 0x3250
callq 0x22c0
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x3172
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3206
movq -0xa8(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x31cf
movq -0xa8(%rbp), %rdi
callq 0x2040
movq -0x80(%rbp), %rdi
callq 0x2040
leaq -0xa0(%rbp), %rdi
addq $0x28, %rdi
callq 0x2140
leaq -0xa0(%rbp), %rdi
addq $0x50, %rdi
callq 0x22f0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/algo.c
// Function: move_segs
static void move_segs(void *km, msseg_v *ret, msseg_aux_v *seg, MG_MSS_TYPE min_sc)
{
    int32_t i;
    for (i = 0; i < seg->n; ++i) {
        msseg_aux_t *p = &seg->a[i];
        if (p->R - p->L >= min_sc) {
            mg_msseg_t *q;
            kv_pushp(mg_msseg_t, km, *ret, &q);
            q->st = p->st, q->en = p->en, q->sc = p->R - p->L;
        }
    }
    seg->n = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3acb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl -0x1c(%rbp), %eax
jl 0x3abb
jmp 0x39ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x3a68
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a2c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x3a37
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x3a37
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
imulq $0xc, 0x8(%rax), %rdx
callq 0x2ae0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x28(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x3abd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x39be
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/algo.c
// Function: mg_wfa_cmp
int32_t mg_wfa_cmp(void *km, int32_t l1, const char *s1, int32_t l2, const char *s2, int32_t max_pen, int32_t *mlen, int32_t *blen)
{
	mwf_opt_t opt;
	mwf_rst_t r;
	int32_t i;
	mwf_opt_init(&opt);
	opt.max_s = max_pen;
	opt.flag |= MWF_F_CIGAR;
	mwf_wfa_exact(km, &opt, l1, s1, l2, s2, &r);
	*mlen = *blen = 0;
	for (i = 0; i < r.n_cigar; ++i) {
		int32_t op = r.cigar[i]&0xf, len = r.cigar[i]>>4;
		*blen += len;
		if (op == 7) *mlen += len;
	}
	kfree(km, r.cigar);
	return r.s < 0? -(l1 + l2) : (l1 + l2) / 2 - r.s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1bbe0
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x68(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
leaq -0x68(%rbp), %rsi
leaq -0x80(%rbp), %rax
movq %rax, (%rsp)
callq 0x1d270
movq 0x18(%rbp), %rax
movl $0x0, (%rax)
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
cmpl -0x7c(%rbp), %eax
jge 0x4804
movq -0x70(%rbp), %rax
movslq -0x84(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x88(%rbp)
movq -0x70(%rbp), %rax
movslq -0x84(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %ecx
movq 0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x7, -0x88(%rbp)
jne 0x47f1
movl -0x8c(%rbp), %ecx
movq 0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x47f3
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x4793
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2670
cmpl $0x0, -0x80(%rbp)
jge 0x4829
movl -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x90(%rbp)
jmp 0x4840
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl -0x80(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/sys.c
// Function: mg_err_fputs
void mg_err_fputs(const char *str, FILE *fp)
{
	int ret;
	ret = fputs(str, fp);
	if (ret == EOF) {
		fprintf(stderr, "[ERROR] failed to write the results\n");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x4968
movq 0x406ab(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x37829(%rip), %rsi     # 0x3c180
movb $0x0, %al
callq 0x2210
movl $0x1, %edi
callq 0x2330
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minigraph/sys.c
// Function: mg_err_fwrite
void mg_err_fwrite(const void *p, size_t size, size_t nitems, FILE *fp)
{
	int ret;
	ret = fwrite(p, size, nitems, fp);
	if (ret == EOF) {
		fprintf(stderr, "[ERROR] failed to write data\n");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2340
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x49c8
movq 0x4064b(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x377ee(%rip), %rsi     # 0x3c1a5
movb $0x0, %al
callq 0x2210
movl $0x1, %edi
callq 0x2330
addq $0x30, %rsp
popq %rbp
retq
nop