LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_u.c
// Function: prefix_print
static t_tags	*prefix_print(t_tags *ids, size_t len)
{
	if (ids->minwth > len && ids->current_flag[4] != '-'
		&& ids->current_flag[1] != '0')
		minwth_print(ids, len);
	else if (ids->minwth > len && ids->current_flag[4] != '-'
	&& ids->current_flag[1] == '0' && ids->period == 1)
		minwth_print(ids, len);
	if ((ids->current_flag[1] == '0' && len < ids->minwth && ids->minwth > 0)
		|| (ids->period == 1 && ids->maxwth > len))
		put_zero_oxu(ids, len);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xa627
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xa627
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
je 0xa627
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xac00
jmp 0xa669
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xa667
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xa667
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xa667
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xa667
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xac00
jmp 0xa669
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xa68f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa68f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
ja 0xa6a8
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xa6b5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xa6b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xaa70
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_df
t_tags			*put_zero_df(t_tags *ids, size_t len)
{
	if (ids->current_type == 'f')
	{
		len += ids->period == 0 ? 7 : ids->maxwth + 1;
	}
	if (ids->current_flag[4] == '-' && ids->minwth > len && ids->period == 0)
		return (ids);
	if (ids->current_flag[3] == '+' && ids->period == 0 && ids->negative == 1)
		len++;
	if (ids->current_flag[1] == '0' && ids->current_flag[2] == ' ' &&
	ids->minwth > len && ids->negative == 1)
		len++;
	if (ids->negative == -1 && ids->maxwth + 1 > len)
		len--;
	write_zero(ids, len);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x66, %eax
jne 0xa70f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa6f3
movl $0x7, %eax
movq %rax, -0x20(%rbp)
jmp 0xa703
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
jne 0xa742
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa742
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa742
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa7eb
movq -0x10(%rbp), %rax
movsbl 0x5b(%rax), %eax
cmpl $0x2b, %eax
jne 0xa770
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa770
movq -0x10(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0xa770
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xa7ae
movq -0x10(%rbp), %rax
movsbl 0x5a(%rax), %eax
cmpl $0x20, %eax
jne 0xa7ae
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa7ae
movq -0x10(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0xa7ae
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0xa7d6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jbe 0xa7d6
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa800
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: write_zero
static t_tags	*write_zero(t_tags *ids, size_t len)
{
	if (ids->period == 1 && ids->current_type != 'f')
	{
		while (ids->maxwth > len)
		{
			write(1, "0", 1);
			ids->printed_chars++;
			ids->minwth--;
			len++;
		}
		return (ids);
	}
	while (ids->minwth > len)
	{
		write(1, "0", 1);
		ids->printed_chars++;
		len++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xa886
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x66, %eax
je 0xa886
jmp 0xa82a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa87c
movl $0x1, %edi
leaq 0x222b(%rip), %rsi      # 0xca6f
movl $0x1, %edx
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa82a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa8d2
jmp 0xa888
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa8ca
movl $0x1, %edi
leaq 0x21cd(%rip), %rsi      # 0xca6f
movl $0x1, %edx
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa888
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_p
t_tags			*put_zero_p(t_tags *ids, size_t len)
{
	if (ids->current_flag[1] == '0' && ids->period == 1 && ids->maxwth < len)
		return (ids);
	else if (ids->current_type == 'p' && ids->current_flag[1] == '0'
	&& ids->period == 0)
		len += 2;
	if (ids->maxwth >= len)
	{
		maxwth_write(ids, len);
		return (ids);
	}
	while (ids->minwth > len)
	{
		write(1, "0", 1);
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xa923
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xa923
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0xa923
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa9c7
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x70, %eax
jne 0xa954
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xa954
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa954
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xa956
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xa97b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa9e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa9c7
jmp 0xa97d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa9bf
movl $0x1, %edi
leaq 0x20d8(%rip), %rsi      # 0xca6f
movl $0x1, %edx
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa97d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: maxwth_write
static t_tags	*maxwth_write(t_tags *ids, size_t len)
{
	while (ids->maxwth > len)
	{
		if (ids->minwth == 0)
			ids->minwth++;
		write(1, "0", 1);
		ids->minwth--;
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xaa5d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xaa19
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, %edi
leaq 0x204a(%rip), %rsi      # 0xca6f
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa9f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_oxu
t_tags			*put_zero_oxu(t_tags *ids, size_t len)
{
	if (ids->current_type == 'u' && ids->current_flag[1] == '0'
	&& ids->period == 1 && ids->maxwth < len)
		return (ids);
	if ((ids->current_type == 'o' || ids->current_type == 'x'
	|| ids->current_type == 'X') && ((ids->current_flag[1] == '0'
	&& ids->period == 1 && ids->maxwth < len)
	|| (ids->current_flag[4] == '-' && ids->minwth > len && ids->period == 0)))
		return (ids);
	if ((ids->current_type == 'x' || ids->current_type == 'X')
	&& ids->current_flag[0] == '#' && ids->maxwth <= len)
		len += 2;
	if (ids->maxwth >= len)
	{
		maxwth_write(ids, len);
		return (ids);
	}
	while (ids->minwth > len)
	{
		write(1, "0", 1);
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x75, %eax
jne 0xaac0
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xaac0
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xaac0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0xaac0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xabf2
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x6f, %eax
je 0xaae7
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x78, %eax
je 0xaae7
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x58, %eax
jne 0xab40
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xab0d
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xab0d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xab33
movq -0x10(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
jne 0xab40
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xab40
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xab40
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xabf2
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x78, %eax
je 0xab5a
movq -0x10(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x58, %eax
jne 0xab81
movq -0x10(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x23, %eax
jne 0xab81
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0xab81
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xaba6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa9e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xabf2
jmp 0xaba8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xabea
movl $0x1, %edi
leaq 0x1ead(%rip), %rsi      # 0xca6f
movl $0x1, %edx
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xaba8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/minwth_print.c
// Function: minwth_print
t_tags			*minwth_print(t_tags *ids, size_t len)
{
	size_t		og_len;

	og_len = len;
	if (ids->current_type == 'd' || ids->current_type == 'i'
	|| ids->current_type == 'c')
		len = mod_len_int_char(ids, len, og_len);
	if (ids->current_type == 'p')
		len = mod_len_ptr(ids, len);
	if (ids->current_type == 'o' || ids->current_type == 'u'
	|| ids->current_type == 'x' || ids->current_type == 'X')
		len = mod_len_oct_udec_hexa(ids, len);
	if (ids->current_type == 'f')
		len = mod_len_dbl(ids, len);
	while (ids->minwth > len)
	{
		write(1, " ", 1);
		ids->printed_chars++;
		len++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x64, %eax
je 0xac3f
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x69, %eax
je 0xac3f
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x63, %eax
jne 0xac54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xad30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x70, %eax
jne 0xac72
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xae80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x6f, %eax
je 0xaca6
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x75, %eax
je 0xaca6
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x78, %eax
je 0xaca6
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x58, %eax
jne 0xacb7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xaf00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x66, %eax
jne 0xacd5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xafa0
movq %rax, -0x10(%rbp)
jmp 0xacd7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xad19
movl $0x1, %edi
leaq 0x1c78(%rip), %rsi      # 0xc969
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xacd7
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/minwth_print.c
// Function: mod_len_int_char
static size_t	mod_len_int_char(t_tags *ids, size_t len, size_t og_len)
{
	if ((ids->current_flag[3] == '+' || ids->current_flag[2] == ' ') &&
		ids->negative == 1)
		len++;
	if (ids->negative == -1 && ids->maxwth > len && ids->current_flag[4] != '-')
		len++;
	else if (ids->negative == -1 && ids->maxwth >= og_len &&
	ids->current_flag[4] != '-' && ids->current_flag[1] == '0')
		len += 2;
	if (ids->maxwth >= og_len && ids->current_flag[4] != '-')
	{
		len += ids->maxwth - og_len;
		if (ids->current_flag[1] == '0' && ids->negative == -1
		&& ids->maxwth == og_len)
			len--;
		else if (ids->negative == -1 && ids->maxwth == og_len)
			len++;
	}
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5b(%rax), %eax
cmpl $0x2b, %eax
je 0xad5a
movq -0x8(%rbp), %rax
movsbl 0x5a(%rax), %eax
cmpl $0x20, %eax
jne 0xad70
movq -0x8(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0xad70
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0xada3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xada3
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xada3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xade3
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0xade1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xade1
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xade1
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xade1
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0xade3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xae6d
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xae6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xae45
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0xae45
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xae45
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xae6b
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0xae69
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xae69
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xae6b
jmp 0xae6d
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/minwth_print.c
// Function: mod_len_ptr
static size_t	mod_len_ptr(t_tags *ids, size_t len)
{
	if (ids->current_flag[1] == '0' && ids->period == 0)
		return (len += ids->minwth);
	if (ids->period == 1 && ids->maxwth >= len - 2)
		len += (ids->maxwth - len) + 2;
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0xaeba
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xaeba
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xaefa
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0xaef2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jb 0xaef2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq -0x18(%rbp), %rax
addq $0x2, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/minwth_print.c
// Function: mod_len_oct_udec_hexa
static size_t	mod_len_oct_udec_hexa(t_tags *ids, size_t len)
{
	if (ids->maxwth > len && ids->current_flag[4] != '-')
		len += ids->maxwth - len;
	if (ids->current_flag[0] == '#'
	&& (ids->current_type == 'x' || ids->current_type == 'X'))
		len += 2;
	else if (ids->current_flag[0] == '#')
		len++;
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0xaf3b
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0xaf3b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq -0x10(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x23, %eax
jne 0xaf70
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x78, %eax
je 0xaf62
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x58, %eax
jne 0xaf70
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0xaf8b
movq -0x8(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x23, %eax
jne 0xaf89
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xaf8b
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeCreateEventLoop
aeEventLoop *aeCreateEventLoop(int setsize) {
    aeEventLoop *eventLoop;
    int i;

    if ((eventLoop = malloc(sizeof(*eventLoop))) == NULL) goto err;
    eventLoop->events = malloc(sizeof(aeFileEvent)*setsize);
    eventLoop->fired = malloc(sizeof(aeFiredEvent)*setsize);
    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
    eventLoop->setsize = setsize;
    eventLoop->lastTime = time(NULL);
    eventLoop->timeEventHead = NULL;
    eventLoop->timeEventNextId = 0;
    eventLoop->stop = 0;
    eventLoop->maxfd = -1;
    eventLoop->beforesleep = NULL;
    if (aeApiCreate(eventLoop) == -1) goto err;
    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return eventLoop;

err:
    if (eventLoop) {
        free(eventLoop->events);
        free(eventLoop->fired);
        free(eventLoop);
    }
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl $0x48, %edi
callq 0x22e0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x25a2
jmp 0x26a9
movslq 0x1c(%rsp), %rdi
shlq $0x5, %rdi
callq 0x22e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x22e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x25ee
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x25f3
jmp 0x26a9
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x22d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x10(%rsp), %rdi
callq 0x26f0
cmpl $-0x1, %eax
jne 0x2663
jmp 0x26a9
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x269d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x266b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x26e0
cmpq $0x0, 0x10(%rsp)
je 0x26d7
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq 0x10(%rsp), %rdi
callq 0x2030
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeApiCreate
static int aeApiCreate(aeEventLoop *eventLoop) {
    aeApiState *state = malloc(sizeof(aeApiState));

    if (!state) return -1;
    state->events = malloc(sizeof(struct epoll_event)*eventLoop->setsize);
    if (!state->events) {
        free(state);
        return -1;
    }
    state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */
    if (state->epfd == -1) {
        free(state->events);
        free(state);
        return -1;
    }
    eventLoop->apidata = state;
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x10, %edi
callq 0x22e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x271b
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x27a6
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rax
imulq $0xc, %rax, %rdi
callq 0x22e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2756
movq (%rsp), %rdi
callq 0x2030
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x27a6
movl $0x400, %edi            # imm = 0x400
callq 0x2410
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x2791
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x27a6
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeResizeSetSize
int aeResizeSetSize(aeEventLoop *eventLoop, int setsize) {
    int i;

    if (setsize == eventLoop->setsize) return AE_OK;
    if (eventLoop->maxfd >= setsize) return AE_ERR;
    if (aeApiResize(eventLoop,setsize) == -1) return AE_ERR;

    eventLoop->events = realloc(eventLoop->events,sizeof(aeFileEvent)*setsize);
    eventLoop->fired = realloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);
    eventLoop->setsize = setsize;

    /* Make sure that if we created new slots, they are initialized with
     * an AE_NONE mask. */
    for (i = eventLoop->maxfd+1; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return AE_OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x27e8
movl $0x0, 0x14(%rsp)
jmp 0x28b7
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x4(%rsp), %eax
jl 0x2802
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x28b7
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x28c0
cmpl $-0x1, %eax
jne 0x2822
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x28b7
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x4(%rsp), %rsi
shlq $0x5, %rsi
callq 0x2330
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x4(%rsp), %rsi
shlq $0x3, %rsi
callq 0x2330
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x28af
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movslq (%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2881
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeDeleteEventLoop
void aeDeleteEventLoop(aeEventLoop *eventLoop) {
    aeApiFree(eventLoop);
    free(eventLoop->events);
    free(eventLoop->fired);
    free(eventLoop);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x2950
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeApiFree
static void aeApiFree(aeEventLoop *eventLoop) {
    aeApiState *state = eventLoop->apidata;

    close(state->epfd);
    free(state->events);
    free(state);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x21d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq 0x8(%rsp), %rdi
callq 0x2030
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeDeleteTimeEvent
int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te, *prev = NULL;

    te = eventLoop->timeEventHead;
    while(te) {
        if (te->id == id) {
            if (prev == NULL)
                eventLoop->timeEventHead = te->next;
            else
                prev->next = te->next;
            if (te->finalizerProc)
                te->finalizerProc(eventLoop, te->clientData);
            free(te);
            return AE_OK;
        }
        prev = te;
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3000
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x2fe4
cmpq $0x0, (%rsp)
jne 0x2f9a
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x2fab
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2fd0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rdi
callq 0x2030
movl $0x0, 0x24(%rsp)
jmp 0x3008
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2f64
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_init
void assoc_init(void) {
    unsigned int hash_size = hashsize(HASHPOWER) * sizeof(void*);
    hashtable = malloc(hash_size);
    if (! hashtable) {
        fprintf(stderr, "Failed to init hashtable.\n");
        exit(1);
    }
    memset(hashtable, 0, hash_size);
}

// Assembly:
pushq %rax
movl $0x800000, 0x4(%rsp)    # imm = 0x800000
movl 0x4(%rsp), %eax
movl %eax, %edi
callq 0x22e0
movq %rax, 0xd31d(%rip)      # 0x11268
cmpq $0x0, 0xd315(%rip)      # 0x11268
jne 0x3f77
movq 0xd09c(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x80d2(%rip), %rsi      # 0xc038
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
movq 0xd2ea(%rip), %rdi      # 0x11268
movl 0x4(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x21b0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_find
item *assoc_find(char *key) {
    ub4 hv = hash(key, strlen(key), 0) & hashmask(HASHPOWER);
    item *it = hashtable[hv];

    while (it) {
        if (strcmp(key, ITEM_key(it)) == 0)
            return it;
        it = it->h_next;
    }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x2110
movq (%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x38e0
andq $0xfffff, %rax          # imm = 0xFFFFF
movq %rax, 0x10(%rsp)
movq 0xd29a(%rip), %rax      # 0x11268
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4018
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
callq 0x2250
cmpl $0x0, %eax
jne 0x4008
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x4021
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3fdc
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_insert
int assoc_insert(char *key, item *it) {
    ub4 hv;
    assert(assoc_find(key) == 0);  /* shouldn't have duplicately named things defined */
    hv = hash(key, strlen(key), 0) & hashmask(HASHPOWER);
    it->h_next = hashtable[hv];
    hashtable[hv] = it;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x38e0
andq $0xfffff, %rax          # imm = 0xFFFFF
movq %rax, 0x10(%rsp)
movq 0xd1f3(%rip), %rax      # 0x11268
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdx
movq 0xd1d5(%rip), %rax      # 0x11268
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_delete
void assoc_delete(char *key) {
    item **before = _hashitem_before(key);
    if (*before) {
        item *nxt = (*before)->h_next;
        (*before)->h_next = 0;   /* probably pointless, but whatever. */
        *before = nxt;
        return;
    }
    /* Note:  we never actually get here.  the callers don't delete things
       they can't find. */
    assert(*before != 0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4110
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x40ff
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: hashitem_before
static item** _hashitem_before (char *key) {
    ub4 hv = hash(key, strlen(key), 0) & hashmask(HASHPOWER);
    item **pos = &hashtable[hv];

    while (*pos && strcmp(key, ITEM_key(*pos))) {
        pos = &(*pos)->h_next;
    }
    return pos;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x38e0
andq $0xfffff, %rax          # imm = 0xFFFFF
movq %rax, 0x18(%rsp)
movq 0xd118(%rip), %rax      # 0x11268
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, 0x7(%rsp)
je 0x4192
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq $0x30, %rsi
callq 0x2250
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x419c
jmp 0x41af
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x4161
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_create
command_service_ptr command_service_create() {
    command_service_ptr cmd_srv;
    cmd_srv = (command_service_ptr)calloc(1, sizeof(command_service));
    if (NULL == cmd_srv) {
        exit(-1);
    }
    return cmd_srv;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x18, %esi
callq 0x2240
movq %rax, (%rsp)
xorl %eax, %eax
cmpq (%rsp), %rax
jne 0x41e6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2430
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_run
int32_t command_service_run(command_service_ptr service, char *cmd_s, int argc, char **argv) {
    command_info_ptr cmd;
    for (cmd = service->command_list; NULL != cmd; cmd = cmd->next) {
        if (FIXED_PREFIX == cmd->type && strncmp(cmd_s, cmd->cmd, cmd->cmd_len) == 0) {
            return cmd->handler(cmd_s, argc, argv);
        }
        if (FULL_MATCH == cmd->type && strcmp(cmd_s, cmd->cmd) == 0) {
            return cmd->handler(cmd_s, argc, argv);
        }
    }
    return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
je 0x4547
movq 0x8(%rsp), %rcx
movl $0x1, %eax
cmpl 0xc(%rcx), %eax
jne 0x44f0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x44f0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x454f
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpl 0xc(%rcx), %eax
jne 0x4532
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x2250
cmpl $0x0, %eax
jne 0x4532
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x454f
jmp 0x4534
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4494
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_destory
void command_service_destory(command_service_ptr service) {
    command_info_ptr cmd, next_cmd;
    
    if (NULL == service) {
        return;
    }
    cmd = service->command_list;
    while (NULL != cmd) {
        next_cmd = cmd->next;
        free(cmd->cmd);
        free(cmd);
        cmd = next_cmd;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jne 0x4574
jmp 0x45b9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
je 0x45b9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2030
movq 0x8(%rsp), %rdi
callq 0x2030
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x4581
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_cleanup
void conn_cleanup(conn *c) {
    if (c->item) {
        item_free(c->item);
        c->item = 0;
    }

    if (c->ileft) {
        for (; c->ileft > 0; c->ileft--,c->icurr++) {
            item_remove(*(c->icurr));
        }
    }

    if (c->write_and_free) {
        free(c->write_and_free);
        c->write_and_free = 0;
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x4b69
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x5950
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movq (%rsp), %rax
cmpl $0x0, 0xb8(%rax)
je 0x4bc5
jmp 0x4b78
movq (%rsp), %rax
cmpl $0x0, 0xb8(%rax)
jle 0x4bc3
movq (%rsp), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rdi
callq 0x5c80
movq (%rsp), %rax
movl 0xb8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb8(%rax)
movq (%rsp), %rax
movq 0xb0(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xb0(%rax)
jmp 0x4b78
jmp 0x4bc5
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x4be9
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_close
void conn_close(conn *c) {
    /* delete the event, the socket and the conn */
    aeDeleteFileEvent(g_el, c->sfd, AE_READABLE); 
    aeDeleteFileEvent(g_el, c->sfd, AE_WRITABLE);

    LOG_DEBUG_F1("<%d connection closed.\n", c->sfd);

    close(c->sfd);
    conn_cleanup(c);

    /* if the connection has big buffers, just free it */
    if (c->rsize > READ_BUFFER_HIGHWAT) {
        conn_free(c);
    } else if (freecurr < freetotal) {
        /* if we have enough space in the free connections array, put the structure there */
        freeconns[freecurr++] = c;
    } else {
        /* try to enlarge free connections array */
        conn **new_freeconns = realloc(freeconns, sizeof(conn *)*freetotal*2);
        if (new_freeconns) {
            freetotal *= 2;
            freeconns = new_freeconns;
            freeconns[freecurr++] = c;
        } else {
            conn_free(c);
        }
    }

    -- stats.curr_conns;

    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xc688(%rip), %rax      # 0x11288
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x2ba0
leaq 0xc66d(%rip), %rax      # 0x11288
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
movl $0x2, %edx
callq 0x2ba0
leaq 0xc662(%rip), %rax      # 0x11298
cmpl $0x1, 0x18(%rax)
jle 0x4c5b
movq 0xc3b5(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0x758d(%rip), %rsi      # 0xc1e1
movb $0x0, %al
callq 0x2280
jmp 0x4c5d
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x21d0
movq 0x10(%rsp), %rdi
callq 0x4b40
movq 0x10(%rsp), %rax
cmpl $0x2000, 0x28(%rax)     # imm = 0x2000
jle 0x4c90
movq 0x10(%rsp), %rdi
callq 0x4d60
jmp 0x4d39
movl 0xc5de(%rip), %eax      # 0x11274
cmpl 0xc5d4(%rip), %eax      # 0x11270
jge 0x4cc4
movq 0x10(%rsp), %rdx
movq 0xc5ce(%rip), %rax      # 0x11278
movl 0xc5c4(%rip), %ecx      # 0x11274
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc5b9(%rip)      # 0x11274
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4d37
movq 0xc5ad(%rip), %rdi      # 0x11278
movslq 0xc59e(%rip), %rsi      # 0x11270
shlq $0x3, %rsi
shlq %rsi
callq 0x2330
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4d2b
movl 0xc57f(%rip), %eax      # 0x11270
shll %eax
movl %eax, 0xc577(%rip)      # 0x11270
movq 0x8(%rsp), %rax
movq %rax, 0xc573(%rip)      # 0x11278
movq 0x10(%rsp), %rdx
movq 0xc567(%rip), %rax      # 0x11278
movl 0xc55d(%rip), %ecx      # 0x11274
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc552(%rip)      # 0x11274
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4d35
movq 0x10(%rsp), %rdi
callq 0x4d60
jmp 0x4d37
jmp 0x4d39
leaq 0xc5b0(%rip), %rax      # 0x112f0
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
leaq 0xc5a3(%rip), %rax      # 0x112f0
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_free
static void conn_free(conn *c) {
    if (c) {
        if (c->hdrbuf)
            free(c->hdrbuf);
        if (c->msglist)
            free(c->msglist);
        if (c->rbuf)
            free(c->rbuf);
        if (c->wbuf)
            free(c->wbuf);
        if (c->ilist)
            free(c->ilist);
        if (c->iov)
            free(c->iov);
        free(c);
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4e1b
movq (%rsp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x4d8e
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x4dac
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4dc4
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4ddc
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x4dfa
movq (%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x2030
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4e12
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: do_realloc
int do_realloc(void **orig, int newsize, int bytes_per_item, int *size) {
    void *newbuf = realloc(*orig, newsize * bytes_per_item);
    if (newbuf) {
        *orig = newbuf;
        *size = newsize;
       return 1;
    }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x14(%rsp), %eax
imull 0x10(%rsp), %eax
movslq %eax, %rsi
callq 0x2330
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x4e7b
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x24(%rsp)
jmp 0x4e83
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_shrink
void conn_shrink(conn *c) {
    if (c->udp)
        return;

    if (c->rsize > READ_BUFFER_HIGHWAT && c->rbytes < DATA_BUFFER_SIZE) {
       do_realloc((void **)&c->rbuf, DATA_BUFFER_SIZE, 1, &c->rsize);
    }

    if (c->isize > ITEM_LIST_HIGHWAT) {
        do_realloc((void **)&c->ilist, ITEM_LIST_INITIAL, sizeof(c->ilist[0]), &c->isize);
    }

    if (c->msgsize > MSG_LIST_HIGHWAT) {
        do_realloc((void **)&c->msglist, MSG_LIST_INITIAL, sizeof(c->msglist[0]), &c->msgsize);
    }

    if (c->iovsize > IOV_LIST_HIGHWAT) {
        do_realloc((void **)&c->iov, IOV_LIST_INITIAL, sizeof(c->iov[0]), &c->iovsize);
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0xbc(%rax)
je 0x4ea7
jmp 0x4f79
movq (%rsp), %rax
cmpl $0x2000, 0x28(%rax)     # imm = 0x2000
jle 0x4ee0
movq (%rsp), %rax
cmpl $0x800, 0x2c(%rax)      # imm = 0x800
jge 0x4ee0
movq (%rsp), %rdi
addq $0x18, %rdi
movq (%rsp), %rcx
addq $0x28, %rcx
movl $0x800, %esi            # imm = 0x800
movl $0x1, %edx
callq 0x4e20
movq (%rsp), %rax
cmpl $0x190, 0xa8(%rax)      # imm = 0x190
jle 0x4f15
movq (%rsp), %rdi
addq $0xa0, %rdi
movq (%rsp), %rcx
addq $0xa8, %rcx
movl $0xc8, %esi
movl $0x8, %edx
callq 0x4e20
movq (%rsp), %rax
cmpl $0x64, 0x90(%rax)
jle 0x4f47
movq (%rsp), %rdi
addq $0x88, %rdi
movq (%rsp), %rcx
addq $0x90, %rcx
movl $0xa, %esi
movl $0x38, %edx
callq 0x4e20
movq (%rsp), %rax
cmpl $0x258, 0x80(%rax)      # imm = 0x258
jle 0x4f79
movq (%rsp), %rdi
addq $0x78, %rdi
movq (%rsp), %rcx
addq $0x80, %rcx
movl $0x190, %esi            # imm = 0x190
movl $0x10, %edx
callq 0x4e20
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_set_state
void conn_set_state(conn *c, int state) {
    if (state != c->state) {
        if (state == conn_read) {
            conn_shrink(c);
        }
        c->state = state;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x4fb8
cmpl $0x1, 0xc(%rsp)
jne 0x4fac
movq 0x10(%rsp), %rdi
callq 0x4e90
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: out_string
void out_string(conn *c, char *str) {
    int len;

    LOG_DEBUG_F2(">%d %s\n", c->sfd, str);

    len = strlen(str);
    if (len + 2 > c->wsize) {
        /* ought to be always enough. just fail for simplicity */
        str = "SERVER_ERROR output line too long";
        len = strlen(str);
    }

    strcpy(c->wbuf, str);
    strcpy(c->wbuf + len, "\r\n");
    c->wbytes = len + 2;
    c->wcurr = c->wbuf;

    conn_set_state(c, conn_write);
    c->write_and_go = conn_read;
    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0xc2c3(%rip), %rax      # 0x11298
cmpl $0x1, 0x18(%rax)
jle 0x4fff
movq 0xc016(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
movq 0x8(%rsp), %rcx
leaq 0x7201(%rip), %rsi      # 0xc1f9
movb $0x0, %al
callq 0x2280
jmp 0x5001
movq 0x8(%rsp), %rdi
callq 0x2110
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0x2, %eax
movq 0x10(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jle 0x503a
leaq 0x71da(%rip), %rax      # 0xc201
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2110
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2090
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movslq 0x4(%rsp), %rax
addq %rax, %rdi
leaq 0x74b6(%rip), %rsi      # 0xc51b
callq 0x2090
movl 0x4(%rsp), %ecx
addl $0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x4f80
movq 0x10(%rsp), %rax
movl $0x1, 0x48(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: add_msghdr
int add_msghdr(conn *c) {
    struct msghdr *msg;

    if (c->msgsize == c->msgused) {
        msg = realloc(c->msglist, c->msgsize * 2 * sizeof(struct msghdr));
        if (! msg)
            return -1;
        c->msglist = msg;
        c->msgsize *= 2;
    }

    msg = c->msglist + c->msgused;

    /* this wipes msg_iovlen, msg_control, msg_controllen, and
       msg_flags, the last 3 of which aren't defined on solaris: */
    memset(msg, 0, sizeof(struct msghdr));

    msg->msg_iov = &c->iov[c->iovused];
    msg->msg_name = &c->request_addr;
    msg->msg_namelen = c->request_addr_size;

    c->msgbytes = 0;
    c->msgused++;

    if (c->udp) {
        /* Leave room for the UDP header, which we'll fill in later. */
        return add_iov(c, NULL, UDP_HEADER_SIZE);
    }

    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x90(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x94(%rcx), %eax
jne 0x5350
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x90(%rax), %eax
shll %eax
cltq
imulq $0x38, %rax, %rsi
callq 0x2330
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x532d
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x541e
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rax
movl 0x90(%rax), %ecx
shll %ecx
movl %ecx, 0x90(%rax)
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x94(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x21b0
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
movq 0x8(%rsp), %rax
movslq 0x84(%rax), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
addq $0xc4, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0xd4(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x9c(%rax)
movq 0x8(%rsp), %rax
movl 0x94(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x94(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0xbc(%rax)
je 0x5416
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
callq 0x50b0
movl %eax, 0x14(%rsp)
jmp 0x541e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)