LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_s.c
// Function: convert_s
int			convert_s(t_mods modifiers, va_list ap)
{
	char	*s;
	char	*s2;
	int		nbyte;
	int		len;

	s = va_arg(ap, char *);
	!s ? s = "(null)" : 0;
	nbyte = 0;
	if (modifiers.prcsn >= 0 && modifiers.prcsn < (int)ft_strlen(s))
		s2 = ft_strndup(s, modifiers.prcsn);
	else
		s2 = ft_strdup(s);
	if ((len = ft_strlen(s2)) && modifiers.fl.minus == 1)
	{
		if (modifiers.width <= len)
			nbyte += (int)write(1, s2, len);
		else
			nbyte += left_justify(modifiers, s2, len);
		return ((ft_pipewrench("-s", &s2) + nbyte) - 1);
	}
	if (modifiers.width > len)
		nbyte += right_justify(modifiers, s2, len);
	else
		nbyte += (int)write(1, s2, len);
	return ((ft_pipewrench("-s", &s2) + nbyte) - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x50(%rsp), %r15
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x8d4d
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x8d59
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
testq %rax, %rax
leaq 0x3bfc(%rip), %rbx      # 0xc962
cmovneq %rax, %rbx
movslq 0x18(%r15), %r14
testq %r14, %r14
js 0x8d8d
movq %rbx, %rdi
callq 0x739e
cmpl %eax, %r14d
jge 0x8d8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7524
jmp 0x8d95
movq %rbx, %rdi
callq 0x74dc
movq %rax, %rbx
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x739e
movq %rax, %r14
movl 0x14(%r15), %r13d
testl %r14d, %r14d
je 0x8df5
cmpl $0x1, 0x8(%r15)
jne 0x8df5
movslq %r14d, %rdx
cmpl %r14d, %r13d
jle 0x8e34
pushq $0x1
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
leaq 0x356b(%rip), %r14      # 0xc342
pushq $0x1
popq %r15
cmpl %r13d, %ebx
jge 0x8e85
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8ddb
cmpl %r14d, %r13d
jle 0x8e31
movq %rbx, 0x8(%rsp)
cmpl $0x1, 0x10(%r15)
jne 0x8e44
xorl %r15d, %r15d
leaq 0x2fac(%rip), %rbx      # 0xbdbc
pushq $0x1
popq %rbp
pushq $0x1
popq %r12
cmpl %r14d, %r13d
jle 0x8e6f
decl %r13d
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x8e17
movslq %r14d, %rdx
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
jmp 0x8e85
xorl %r15d, %r15d
leaq 0x34f4(%rip), %rbx      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r12
cmpl %r14d, %r13d
jle 0x8e6f
decl %r13d
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x8e55
movslq %r14d, %rdx
pushq $0x1
popq %rdi
movq 0x8(%rsp), %rsi
callq 0x1050
movq %rax, %rbx
addl %r15d, %ebx
leaq 0x2f1d(%rip), %rdi      # 0xbda9
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x67f0
addl %ebx, %eax
decl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_percent.c
// Function: convert_percent
int				convert_percent(t_mods modifiers)
{
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(modifiers.width, modifiers.fl.fzero));
	}
	return ((int)write(1, "%", 1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x44(%rsp), %r12d
cmpl $0x1, 0x38(%rsp)
jne 0x9696
leaq 0x3315(%rip), %rsi      # 0xc96c
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
cmpl %ebx, %r12d
jle 0x972e
leaq 0x2ccd(%rip), %r14      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %r12d, %ebx
jge 0x972e
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x967c
cmpl $0x2, %r12d
jl 0x96d3
leaq 0x30(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x96ea
xorl %r15d, %r15d
leaq 0x270b(%rip), %rbx      # 0xbdbc
pushq $0x1
popq %rbp
pushq $0x1
popq %r14
cmpl $0x2, %r12d
jl 0x9716
decl %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x96b8
leaq 0x3292(%rip), %rsi      # 0xc96c
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
jmp 0x972e
xorl %r15d, %r15d
leaq 0x2c4e(%rip), %rbx      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r14
cmpl $0x2, %r12d
jl 0x9716
decl %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x96fb
leaq 0x324f(%rip), %rsi      # 0xc96c
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
addl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: ft_padding
int				ft_padding(char *buf, int len, t_mod mod, int nbyte)
{
	char	*pad_char;

	if ((pad_char = " ") && (len > mod.prcsn || mod.prcsn == -1))
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (!nbyte)
			{
				if (mod.fl.space && mod.fl.fzero)
					add_one_to_buf(&buf, *pad_char, &nbyte);
				while (mod.width - len - mod.neg > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
			else
			{
				while (mod.width - len > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
		}
	}
	else
		while (mod.width - mod.prcsn - mod.neg > nbyte)
			add_one_to_buf(&buf, *pad_char, &nbyte);
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %eax
movl %esi, %ebx
leaq 0x40(%rsp), %r14
movq %rdi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0x14(%r14), %r15d
movl 0x18(%r14), %ecx
cmpl %esi, %ecx
setl %dl
cmpl $-0x1, %ecx
sete %sil
orb %dl, %sil
je 0x9a78
movl %r15d, %ebp
subl %ebx, %ebp
jle 0x9af4
movl 0x10(%r14), %esi
testl %esi, %esi
leaq 0x2382(%rip), %rdx      # 0xbdbc
leaq 0x2901(%rip), %rdi      # 0xc342
cmoveq %rdi, %rdx
cmpl $-0x1, %ecx
cmovneq %rdi, %rdx
testl %eax, %eax
je 0x9aa4
movsbl (%rdx), %ebx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl %eax, %ebp
jle 0x9af4
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x999c
movl 0xc(%rsp), %eax
jmp 0x9a5d
addl 0x20(%r14), %ecx
subl %ecx, %r15d
leaq 0x10(%rsp), %rbx
pushq $0x20
popq %rbp
leaq 0xc(%rsp), %r14
cmpl %eax, %r15d
jle 0x9af4
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x999c
movl 0xc(%rsp), %eax
jmp 0x9a8c
testl %esi, %esi
setne %al
cmpl $0x0, (%r14)
setne %cl
andb %al, %cl
movsbl (%rdx), %ebp
cmpb $0x1, %cl
jne 0x9acb
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movl %ebp, %esi
callq 0x999c
addl 0x20(%r14), %ebx
subl %ebx, %r15d
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
movl 0xc(%rsp), %eax
cmpl %eax, %r15d
jle 0x9af4
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x999c
jmp 0x9adc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: left_jut
void			left_jut(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	if ((len = (int)ft_strlen(num)) && mod.neg == 1)
		ft_strcpy(buf, "-");
	else if (mod.neg == 0)
	{
		if (mod.fl.fplus)
			ft_strcpy(buf, "+");
		else if (mod.fl.space)
			ft_strcpy(buf, "-");
	}
	buf++;
	while (mod.prcsn-- > len)
	{
		ft_strcpy(buf, "0");
		buf++;
	}
	add_to_buf(&buf, num, &nbyte, len);
	while (nbyte < mod.width)
	{
		add_one_to_buf(&buf, ' ', &nbyte);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r13
movl %edx, 0xc(%rsp)
movq %rsi, %rdi
callq 0x739e
movq %rax, %r15
testl %r15d, %r15d
setne %cl
movl 0x20(%r13), %eax
cmpl $0x1, %eax
sete %dl
leaq 0x2e19(%rip), %rsi      # 0xc957
testb %dl, %cl
je 0x9b4c
movq %r14, %rdi
callq 0x7190
jmp 0x9b50
testl %eax, %eax
je 0x9bbf
movl 0x18(%r13), %ebp
incq %r14
leaq 0x225e(%rip), %r12      # 0xbdbc
cmpl %r15d, %ebp
jle 0x9b75
decl %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x7190
incq %r14
jmp 0x9b5e
leaq 0x10(%rsp), %r12
movq %r14, (%r12)
leaq 0xc(%rsp), %r14
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x99c8
movl 0x14(%r13), %ebp
pushq $0x20
popq %rbx
cmpl %ebp, 0xc(%rsp)
jge 0x9bb0
movq %r12, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x999c
jmp 0x9b9b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0xc(%r13)
je 0x9bd2
leaq 0x2d8c(%rip), %rsi      # 0xc959
jmp 0x9b42
cmpl $0x0, (%r13)
jne 0x9b42
jmp 0x9b50
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/c_to_buf.c
// Function: c_to_buf
int				c_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	char	c;
	int		n;

	c = va_arg(ap, int);
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(buf, c, modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(buf, c, modifiers.width, modifiers.fl.fzero));
	}
	n = 0;
	add_one_to_buf(&buf, c, &n);
	return (n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x50(%rsp), %rax
movq %rdi, 0x18(%rsp)
movl (%rsi), %edx
cmpq $0x28, %rdx
ja 0x9c10
movq %rdx, %rcx
addq 0x10(%rsi), %rcx
addl $0x8, %edx
movl %edx, (%rsi)
jmp 0x9c1c
movq 0x8(%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsi)
movl (%rcx), %r12d
movl 0x14(%rax), %r15d
cmpl $0x1, 0x8(%rax)
jne 0x9c7b
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
movsbl %r12b, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x999c
movl (%rbx), %eax
cmpl %r15d, %eax
jge 0x9d02
leaq 0x10(%rsp), %rbx
pushq $0x20
popq %rbp
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x999c
movl 0xc(%rsp), %eax
cmpl %r15d, %eax
jl 0x9c60
jmp 0x9d02
cmpl $0x2, %r15d
jl 0x9cb7
movl 0x10(%rax), %eax
movq %rdi, 0x10(%rsp)
andl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rbx
testl %eax, %eax
je 0x9cca
pushq $0x30
popq %rbp
leaq 0xc(%rsp), %r14
cmpl $0x2, %r15d
jl 0x9cea
decl %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x999c
jmp 0x9c9f
leaq 0x10(%rsp), %rbx
andl $0x0, (%rbx)
movsbl %r12b, %esi
leaq 0x18(%rsp), %rdi
jmp 0x9cf8
pushq $0x20
popq %rbp
leaq 0xc(%rsp), %r14
cmpl $0x2, %r15d
jl 0x9cea
decl %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x999c
jmp 0x9cd2
movsbl %r12b, %esi
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x999c
movl (%rbx), %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/s_to_buf.c
// Function: s_to_buf
int			s_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	char	*s;
	char	*s2;
	int		len;

	s = va_arg(ap, char *);
	!s ? s = "(null)" : 0;
	if (modifiers.prcsn >= 0 && modifiers.prcsn < (int)ft_strlen(s))
		s2 = ft_strndup(s, modifiers.prcsn);
	else
		s2 = ft_strdup(s);
	if ((len = ft_strlen(s2)) && modifiers.fl.minus == 1)
	{
		if (modifiers.width <= len)
			ft_strcpy(buf, s2);
		else
			left_justify(buf, s2, len, modifiers);
		free(s2);
		return (modifiers.width <= len ? len : modifiers.width);
	}
	if (modifiers.width > len)
		right_justify(buf, s2, len, modifiers);
	else
		ft_strcpy(buf, s2);
	free(s2);
	return (modifiers.width > len ? modifiers.width : len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movl (%rsi), %ecx
cmpq $0x28, %rcx
ja 0xa0c8
movq %rcx, %rax
addq 0x10(%rsi), %rax
addl $0x8, %ecx
movl %ecx, (%rsi)
jmp 0xa0d4
movq 0x8(%rsi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq (%rax), %rax
testq %rax, %rax
leaq 0x2881(%rip), %rbx      # 0xc962
cmovneq %rax, %rbx
movslq 0x18(%r12), %r14
testq %r14, %r14
js 0xa109
movq %rbx, %rdi
callq 0x739e
cmpl %eax, %r14d
jge 0xa109
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7524
jmp 0xa111
movq %rbx, %rdi
callq 0x74dc
movq %rax, %r13
movq %rax, %rdi
callq 0x739e
movq %rax, %r14
movl 0x14(%r12), %ebx
testl %r14d, %r14d
je 0xa179
cmpl $0x1, 0x8(%r12)
jne 0xa179
cmpl %r14d, %ebx
jle 0xa1be
leaq 0x8(%rsp), %r12
movq %r15, (%r12)
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x99c8
pushq $0x20
popq %rbp
cmpl %ebx, 0x4(%rsp)
jge 0xa207
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x999c
jmp 0xa160
cmpl %r14d, %ebx
jle 0xa1be
movq %r13, 0x10(%rsp)
movl 0x10(%r12), %eax
movq %r15, 0x8(%rsp)
andl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %r15
cmpl $0x1, %eax
jne 0xa1cb
pushq $0x30
popq %rbp
leaq 0x4(%rsp), %r12
movl %ebx, %r13d
cmpl %r14d, %r13d
jle 0xa1ed
decl %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x999c
jmp 0xa1a7
movq %r15, %rdi
movq %r13, %rsi
callq 0x7190
jmp 0xa207
pushq $0x20
popq %rbp
leaq 0x4(%rsp), %r12
movl %ebx, %r13d
cmpl %r14d, %r13d
jle 0xa1ed
decl %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x999c
jmp 0xa1d6
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq 0x10(%rsp), %r13
movq %r13, %rsi
movl %r14d, %ecx
callq 0x99c8
movq %r13, %rdi
callq 0x1030
cmpl %r14d, %ebx
cmovgl %ebx, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/x_to_buf.c
// Function: pos_justify
static void		pos_justify(char *buf, t_mod mod, int len)
{
	int		nbyte;

	nbyte = 0;
	mod.neg = mod.fl.fplus;
	nbyte = ft_padding(buf, len, mod, nbyte);
	if (!mod.fl.fplus && mod.fl.space && !nbyte)
	{
		ft_strcpy(buf, " ");
		buf++;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x4c(%rsp), %eax
movl %eax, 0x60(%rsp)
movl %eax, 0x20(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %edx, %edx
callq 0x99ed
cmpl $0x0, 0x4c(%rsp)
jne 0xa911
cmpl $0x0, 0x40(%rsp)
je 0xa911
testl %eax, %eax
jne 0xa911
leaq 0x1a3e(%rip), %rsi      # 0xc342
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x7190
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_itoa_base
char	*ft_itoa_base(int n, int base)
{
	int		tmp;
	int		len;
	char	*str;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	n < 0 ? n *= -1 : 0;
	tmp = n;
	len = 1;
	while (tmp /= base)
		len++;
	tmp = n;
	base == 10 ? len += 1 : 0;
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = g_base[(tmp % base)];
		tmp /= base;
	}
	if (n < 0 && base == 10)
		str[0] = '-';
	return (str);
}

// Assembly:
movl %edi, %eax
negl %eax
jno 0xa92a
leaq 0x2049(%rip), %rdi      # 0xc96e
jmp 0x74dc
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
cmovnsl %eax, %ebp
xorl %r14d, %r14d
movl %ebp, %eax
cltd
idivl %ebx
incq %r14
testl %eax, %eax
jne 0xa93a
xorl %edi, %edi
cmpl $0xa, %ebx
sete %dil
addq %r14, %rdi
callq 0x7428
testq %rax, %rax
je 0xa99d
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xa, %ebx
sete %al
leaq (%rax,%r14), %rsi
negq %rsi
movq %rcx, %rdi
addq %rax, %rdi
xorl %r8d, %r8d
leaq 0x1fc4(%rip), %r9       # 0xc940
cmpq %r8, %rsi
je 0xa99f
movl %ebp, %eax
cltd
idivl %ebx
movslq %edx, %rdx
movb (%rdx,%r9), %dl
leaq (%rdi,%r8), %r10
movb %dl, -0x1(%r14,%r10)
decq %r8
movl %eax, %ebp
jmp 0xa97c
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_uitoa_base
char	*ft_uitoa_base(unsigned int n, int base)
{
	unsigned int	tmp;
	int				len;
	char			*str;

	tmp = n;
	len = 1;
	while (tmp /= base)
		len++;
	tmp = n;
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = g_base[(tmp % base)];
		tmp /= base;
	}
	return (str);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
xorl %r14d, %r14d
movl %edi, %eax
cmpl %ebx, %eax
jb 0xa9c1
xorl %edx, %edx
divl %ebx
incq %r14
jmp 0xa9b4
leaq 0x1(%r14), %rdi
callq 0x7428
movq %rax, %rcx
testq %rax, %rax
je 0xa9f3
leaq 0x1f67(%rip), %rsi      # 0xc940
cmpq $-0x1, %r14
je 0xa9f3
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movb (%rdx,%rsi), %dl
movb %dl, (%rcx,%r14)
decq %r14
movl %eax, %ebp
jmp 0xa9d9
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	int		tmp;
	int		len;
	char	*str;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	tmp = n;
	len = 0;
	if (n < 0)
	{
		tmp *= -1;
		len = 1;
	}
	len += ft_intlen(n);
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = tmp % 10 + '0';
		tmp = tmp / 10;
	}
	if (n < 0)
		str[0] = '-';
	return (str);
}

// Assembly:
movl %edi, %eax
negl %eax
jno 0xaa0d
leaq 0x1f66(%rip), %rdi      # 0xc96e
jmp 0x74dc
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %ebp
shrl $0x1f, %ebp
callq 0x7384
addl %ebp, %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x7428
testq %rax, %rax
je 0xaa5f
movq %rax, %rcx
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
pushq $0xa
popq %rsi
movq %r14, %rdi
subq $0x1, %rdi
jb 0xaa56
xorl %edx, %edx
divl %esi
orb $0x30, %dl
movb %dl, -0x1(%rcx,%r14)
movq %rdi, %r14
jmp 0xaa3f
testl %ebx, %ebx
jns 0xaa61
movb $0x2d, (%rcx)
jmp 0xaa61
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: connectToServer
FILE* connectToServer() {
    char *sp = getenv("LINITSOCK");
    if(sp == NULL) {
        fprintf(stderr, "[FATAL] LINITSOCK not set\n");
        exit(65);
    }
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if(fd == -1) {
        fprintf(stderr, "[FATAL] Failed to create socket: %s\n", strerror(errno));
        exit(65);
    }
    struct sockaddr_un addr = { .sun_family = AF_UNIX };
    if((strlen(sp) + 1) > sizeof(addr.sun_path)) {
        fprintf(stderr, "[FATAL] Socket path is too long\n");
        exit(65);
    }
    strcpy(addr.sun_path, sp);
    if(connect(fd, (struct sockaddr *) &addr, sizeof(struct sockaddr_un)) == -1) {
        fprintf(stderr, "[FATAL] Failed to connect: %s\n", strerror(errno));
        exit(65);
    }
    FILE* stream = fdopen(fd, "r+");
    if(stream == NULL) {
        fprintf(stderr, "[FATAL] Failed to convert fd to stream\n");
        exit(65);
    }
    return stream;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0xdba(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
je 0x12ed
movq %rax, %r14
pushq $0x1
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1302
movl %eax, %ebx
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
movups %xmm0, 0x5c(%rsp)
movups %xmm0, 0x4c(%rsp)
movups %xmm0, 0x3c(%rsp)
movups %xmm0, 0x2c(%rsp)
movups %xmm0, 0x1c(%rsp)
movups %xmm0, 0xc(%rsp)
movw $0x1, 0xa(%rsp)
movq %r14, %rdi
callq 0x1080
addq $-0x6c, %rax
cmpq $-0x6e, %rax
jbe 0x1321
leaq 0xc(%rsp), %rdi
movq %r14, %rsi
callq 0x1060
leaq 0xa(%rsp), %rsi
pushq $0x6e
popq %rdx
movl %ebx, %edi
callq 0x10e0
cmpl $-0x1, %eax
je 0x1336
leaq 0xdb5(%rip), %rsi       # 0x208e
movl %ebx, %edi
callq 0x10c0
testq %rax, %rax
je 0x1362
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq 0x2d04(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd10(%rip), %rdi       # 0x200e
pushq $0x1a
jmp 0x1375
movq 0x2cef(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
callq 0x1050
movl (%rax), %edi
callq 0x1100
leaq 0xd0a(%rip), %rsi       # 0x2029
jmp 0x1353
movq 0x2cd0(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd1c(%rip), %rdi       # 0x204e
pushq $0x20
jmp 0x1375
movq 0x2cbb(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
callq 0x1050
movl (%rax), %edi
callq 0x1100
leaq 0xd1c(%rip), %rsi       # 0x206f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
jmp 0x137e
movq 0x2c8f(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd1e(%rip), %rdi       # 0x2091
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x41
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: rcvResp
char *rcvResp(FILE* stream) {
    char* buf = NULL;
    size_t n = 0;
    if(getdelim(&buf, &n, '\0', stream) == -1) {
        fprintf(stderr, "[FATAL] Failed to read response\n");
        exit(65);
    }
    return buf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, %rcx
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
xorl %edx, %edx
callq 0x1120
cmpq $-0x1, %rax
je 0x13b6
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
movq 0x2c3b(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xcf2(%rip), %rdi       # 0x20b9
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x41
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: cmd_state
void cmd_state(int argc, char **argv, FILE *stream) {
    if(argc != 2) {
        fprintf(stderr, "[FATAL] Missing arguments\n");
        exit(1);
    }
    char pre[] = "state ";
    size_t n = strlen(pre) + strlen(argv[0]) + strlen(argv[1]) + 2;
    char buf[n];
    char *b = buf;
    strcpy(b, pre);
    b += strlen(pre);
    strcpy(b, argv[0]);
    b += strlen(argv[0]);
    *b = ' ';
    b++;
    strcpy(b, argv[1]);
    if(fwrite(buf, n, 1, stream) != 1) {
        fprintf(stderr, "[FATAL] Failed to write command\n");
        exit(65);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x1665
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %r12
movq %r12, %rdi
callq 0x1080
movq %rax, %r13
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x1080
leaq (%rax,%r13), %r15
addq $0x8, %r15
addq %r13, %rax
addq $0x17, %rax
andq $-0x10, %rax
movq %rsp, %rcx
movq %rcx, %r13
subq %rax, %r13
negq %rax
movq %r13, %rsp
movl $0x74617473, (%rcx,%rax) # imm = 0x74617473
movl $0x206574, 0x3(%r13)    # imm = 0x206574
leaq 0x6(%r13), %rdi
movq %r12, %rsi
callq 0x1060
movq %r12, %rdi
callq 0x1080
leaq (%rax,%r13), %rdi
addq $0x7, %rdi
movb $0x20, -0x1(%rdi)
movq %r14, %rsi
callq 0x1060
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x10f0
cmpq $0x1, %rax
jne 0x1685
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x298c(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xa64(%rip), %rdi       # 0x20da
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x1
jmp 0x16a3
movq 0x296c(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xa5f(%rip), %rdi       # 0x20f5
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x41
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: cmd_stop
void cmd_stop(int argc, char **argv, FILE *stream) {
    if(argc != 1) {
        fprintf(stderr, "[FATAL] Missing arguments\n");
        exit(1);
    }
    char pre[] = "stop ";
    size_t n = strlen(pre) + strlen(argv[0]) + 1;
    char buf[n];
    char *b = buf;
    strcpy(b, pre);
    b += strlen(pre);
    strcpy(b, argv[0]);
    if(fwrite(buf, n, 1, stream) != 1) {
        fprintf(stderr, "[FATAL] Failed to write command\n");
        exit(65);
    }
    //wait for completion
    while(true) {
        char *resp = rcvResp(stream);
        char *stat = NULL;
        int nspace = 0;
        for(size_t i = 0; (resp[i] != '\0') && (nspace < 2); i++) {
            if(resp[i] == ' ') {
                stat = resp + i;
                nspace++;
            }
        }
        stat++;
        if(nspace < 2) {
            fprintf(stderr, "[FATAL] Bad response: \"%s\"\n", resp);
            exit(65);
        }
        if(strcmp(stat, "stopped") == 0) {
            free(resp);
            return;
        }
        free(resp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, %edi
jne 0x17a2
movq %rdx, %rbx
movq (%rsi), %r14
movq %r14, %rdi
callq 0x1080
leaq 0x6(%rax), %r15
movq %rsp, %rcx
addq $0x15, %rax
andq $-0x10, %rax
movq %rcx, %r12
subq %rax, %r12
movq %r12, %rsp
negq %rax
movl $0x706f7473, (%rcx,%rax) # imm = 0x706F7473
movw $0x20, 0x4(%r12)
leaq 0x5(%r12), %rdi
movq %r14, %rsi
callq 0x1060
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x10f0
cmpq $0x1, %rax
jne 0x17c2
leaq 0xa47(%rip), %r14       # 0x216b
movq %rbx, %rdi
callq 0x1386
movq %rax, %r15
xorl %edi, %edi
xorl %ecx, %ecx
movb (%rax), %dl
testb %dl, %dl
je 0x1752
cmpl $0x2, %ecx
jae 0x1752
xorl %esi, %esi
cmpb $0x20, %dl
sete %sil
cmoveq %rax, %rdi
addl %esi, %ecx
incq %rax
jmp 0x1733
cmpl $0x2, %ecx
jb 0x177f
incq %rdi
movq %r14, %rsi
callq 0x1090
movl %eax, %r12d
movq %r15, %rdi
callq 0x1040
testl %r12d, %r12d
jne 0x1724
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2872(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x9aa(%rip), %rsi       # 0x213a
movq %r15, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x41
popq %rdi
callq 0x10d0
movq 0x284f(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x927(%rip), %rdi       # 0x20da
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x1
jmp 0x179c
movq 0x282f(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x922(%rip), %rdi       # 0x20f5
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
jmp 0x179a
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: svcx
void svcx(char *svc, char *op, FILE *stream) {
    fclose(stream); //stream not necessary
    //get path to initd file
    char pre[] = "/etc/init.d/";
    char svcp[strlen(pre) + strlen(svc) + 1];
    strcpy(svcp, pre);
    strcpy(svcp + strlen(pre), svc);
    //exec
    char *cmd[] = {svcp, op, NULL};
    execv(svcp, cmd);
    fprintf(stderr, "[FATAL] Exec error: %s\n", strerror(errno));
    exit(65);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1080
movq %rsp, %rcx
addq $0x1c, %rax
andq $-0x10, %rax
movq %rcx, %r15
subq %rax, %r15
movq %r15, %rsp
negq %rax
movabsq $0x696e692f6374652f, %rdx # imm = 0x696E692F6374652F
movq %rdx, (%rcx,%rax)
movabsq $0x2f642e74696e69, %rax # imm = 0x2F642E74696E69
movq %rax, 0x5(%r15)
leaq 0xc(%r15), %rdi
movq %r14, %rsi
callq 0x1060
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
movq %rbx, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
movq %r15, %rdi
callq 0x1110
movq 0x2797(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
callq 0x1050
movl (%rax), %edi
callq 0x1100
leaq 0x909(%rip), %rsi       # 0x2180
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x41
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: cmd_enable
void cmd_enable(int argc, char **argv, FILE *stream) {
    if(argc != 1) {
        fprintf(stderr, "[FATAL] Missing arguments\n");
        exit(1);
    }
    svcx(argv[0], "enable", stream);
}

// Assembly:
pushq %rax
cmpl $0x1, %edi
jne 0x18a1
movq (%rsi), %rdi
leaq 0x8fc(%rip), %rsi       # 0x2198
callq 0x17e0
movq 0x2750(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x828(%rip), %rdi       # 0x20da
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: cmd_disable
void cmd_disable(int argc, char **argv, FILE *stream) {
    if(argc != 1) {
        fprintf(stderr, "[FATAL] Missing arguments\n");
        exit(1);
    }
    svcx(argv[0], "disable", stream);
}

// Assembly:
pushq %rax
cmpl $0x1, %edi
jne 0x18da
movq (%rsi), %rdi
leaq 0x8ca(%rip), %rsi       # 0x219f
callq 0x17e0
movq 0x2717(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x7ef(%rip), %rdi       # 0x20da
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/panux[P]linit/src/linitctl.c
// Function: main
int main(int argc, char** argv) {
    if(argc < 2) {
        fprintf(stderr, "[FATAL] Insufficient arguments\n");
        return 1;
    }
    FILE* stream = connectToServer();
    if(strcmp(argv[1], "start") == 0) {
        cmd_start(argc - 2, argv + 2, stream);
    } else if(strcmp(argv[1], "stop") == 0) {
        cmd_stop(argc - 2, argv + 2, stream);
    } else if(strcmp(argv[1], "enable") == 0) {
        cmd_enable(argc - 2, argv + 2, stream);
    } else if(strcmp(argv[1], "disable") == 0) {
        cmd_disable(argc - 2, argv + 2, stream);
    } else if(strcmp(argv[1], "state") == 0) {
        cmd_state(argc - 2, argv + 2, stream);
    } else {
        fprintf(stderr, "[FATAL] Unrecognized subcommand: \"%s\"\n", argv[1]);
        return 1;
    }
    if(fclose(stream) != 0) {
        fprintf(stderr, "[FATAL] Failed to close stream: %s\n", strerror(errno));
        return 65;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x19e5
movq %rsi, %r14
movl %edi, %ebp
callq 0x123c
movq %rax, %rbx
movq 0x8(%r14), %r15
leaq 0x8a1(%rip), %rsi       # 0x21c7
movq %r15, %rdi
callq 0x1090
testl %eax, %eax
je 0x19a0
leaq 0x894(%rip), %rsi       # 0x21cd
movq %r15, %rdi
callq 0x1090
testl %eax, %eax
je 0x19b6
leaq 0x84c(%rip), %rsi       # 0x2198
movq %r15, %rdi
callq 0x1090
testl %eax, %eax
je 0x1a51
leaq 0x83c(%rip), %rsi       # 0x219f
movq %r15, %rdi
callq 0x1090
testl %eax, %eax
je 0x1a65
leaq 0x858(%rip), %rsi       # 0x21d2
movq %r15, %rdi
callq 0x1090
testl %eax, %eax
jne 0x1a31
addl $-0x2, %ebp
addq $0x10, %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15af
jmp 0x19ca
addl $-0x2, %ebp
addq $0x10, %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13da
jmp 0x19ca
addl $-0x2, %ebp
addq $0x10, %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16a9
movq %rbx, %rdi
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1a03
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x260c(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x7b1(%rip), %rdi       # 0x21a7
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
jmp 0x1a4c
movq 0x25ee(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
callq 0x1050
movl (%rax), %edi
callq 0x1100
leaq 0x7df(%rip), %rsi       # 0x21ff
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x41
jmp 0x1a4e
movq 0x25c0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x796(%rip), %rsi       # 0x21d8
movq %r15, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rax
jmp 0x19da
addl $-0x2, %ebp
addq $0x10, %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x188c
addl $-0x2, %ebp
addq $0x10, %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18c5
// File: /workspace/github_c_makefile_star2_O2/cyb70289[P]tt/tests/graph.c
// Function: main
int main(void)
{
	/* a --> b ---> c <--> d
	 * ^   / |      |      |
	 * |  /  |      |      |
	 * | v   v      v      v
	 * e --> f <--> g ---> h---
	 *                     ^  |
	 *                     |  |
	 *                     ----
	 */
	const char *graph[8] = {
		"b",
		"cef",
		"dg",
		"ch",
		"af",
		"g",
		"fh",
		"h",
	};

	/* Finish time */
	int ft[8];
	for (int i = 0; i < 8; i++)
		ft[i] = 0;

	/* First DFS */
	dfs(graph, 8, ft, 1);

	/* Compute transpose of graph */
	char *graph2[8], *v[8];
	for (int i = 0; i < 8; i++) {
		graph2[i] = malloc(9);
		v[i] = graph2[i];
	}
	for (int i = 0; i < 8; i++) {
		const char *p = graph[i];
		while (*p) {
			int j = *p - 'a';
			*v[j] = i + 'a';
			v[j]++;
			p++;
		}
	}
	for (int i = 0; i < 8; i++)
		*v[i] = '\0';

	dfs((const char **)graph2, 8, ft, 2);

	for (int i = 0; i < 8; i++)
		free(graph2[i]);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
xorl %eax, %eax
cmpq $0x8, %rax
je 0x1189
andl $0x0, (%rsp,%rax,4)
incq %rax
jmp 0x117a
leaq 0x2c10(%rip), %rbx      # 0x3da0
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1244
xorl %r15d, %r15d
pushq $0x9
popq %r14
cmpq $0x8, %r15
je 0x11c2
movq %r14, %rdi
callq 0x1060
movq %rax, 0x60(%rsp,%r15,8)
movq %rax, 0x20(%rsp,%r15,8)
incq %r15
jmp 0x11a5
xorl %eax, %eax
cmpq $0x8, %rax
je 0x11f9
movq (%rbx,%rax,8), %rcx
leal 0x61(%rax), %edx
movsbq (%rcx), %rsi
testq %rsi, %rsi
je 0x11f4
movq -0x2e8(%rsp,%rsi,8), %rdi
movb %dl, (%rdi)
incq %rdi
movq %rdi, -0x2e8(%rsp,%rsi,8)
incq %rcx
jmp 0x11d1
incq %rax
jmp 0x11c4
xorl %eax, %eax
cmpq $0x8, %rax
je 0x120e
movq 0x20(%rsp,%rax,8), %rcx
movb $0x0, (%rcx)
incq %rax
jmp 0x11fb
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
pushq $0x2
popq %rdx
callq 0x1244
xorl %ebx, %ebx
cmpq $0x8, %rbx
je 0x1235
movq 0x60(%rsp,%rbx,8), %rdi
callq 0x1030
incq %rbx
jmp 0x1220
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cyb70289[P]tt/tests/graph.c
// Function: dfs
static void dfs(const char *graph[], int n, int ft[], int round)
{
	int i, scc = 1;

	/* Mark all vertex white */
	int color[n];
	for (i = 0; i < n; i++)
		color[i] = WHITE;

	printf("Round%d: \n", round);

	/* Call dfs-visit on all vertex */
	while ((i = dfs_next_vertex(n, color, ft)) >= 0) {
		if (round == 2)
			printf("SCC%d: ", scc++);
		dfs_visit(graph, n, ft, color, i);
		if (round == 2)
			printf("\n");
	}

	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
cmpq $0x8, %rax
je 0x126c
andl $0x0, 0x10(%rsp,%rax,4)
incq %rax
jmp 0x125c
leaq 0xda3(%rip), %rdi       # 0x2016
movl %ebx, %esi
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rax
movq %rax, 0x8(%rsp)
pushq $-0x1
popq %r13
leaq 0x10(%rsp), %r12
movl %ebx, 0x4(%rsp)
xorl %eax, %eax
movl %r13d, %ecx
movl %r13d, %ebp
cmpq $0x8, %rax
je 0x12b7
cmpl $0x0, 0x10(%rsp,%rax,4)
jne 0x12b2
movl (%r14,%rax,4), %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
cmovgl %eax, %ebp
incq %rax
jmp 0x1299
testl %ebp, %ebp
js 0x1311
cmpl $0x2, %ebx
jne 0x12f5
movq %r12, %rbx
movl %r13d, %r12d
movq %r15, %r13
movq 0x8(%rsp), %rsi
leal 0x1(%rsi), %r15d
leaq 0xd48(%rip), %rdi       # 0x2021
xorl %eax, %eax
callq 0x1050
movl %r15d, %eax
movq %rax, 0x8(%rsp)
movq %r13, %r15
movl %r12d, %r13d
movq %rbx, %r12
movl 0x4(%rsp), %ebx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x1327
cmpl $0x2, %ebx
jne 0x1291
pushq $0xa
popq %rdi
callq 0x1040
jmp 0x1291
pushq $0xa
popq %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/cyb70289[P]tt/tests/graph.c
// Function: dfs_visit
static void dfs_visit(const char *graph[], int n, int ft[], int color[], int i)
{
	visit_count++;
	color[i] = GRAY;

	const char *v = graph[i];
	while (*v) {
		int j = *v - 'a';
		if (color[j] == WHITE)
			dfs_visit(graph, n, ft, color, j);
		v++;
	}

	color[i] = BLACK;
	visit_count++;

	printf("%c ", i + 'a');
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
incl 0x2d14(%rip)            # 0x404c
movq %rdi, %r15
movslq %edx, %rbx
movl $0x1, (%rsi,%rbx,4)
movq (%rdi,%rbx,8), %r12
movsbq (%r12), %rdx
testq %rdx, %rdx
je 0x1372
cmpl $0x0, -0x184(%r14,%rdx,4)
jne 0x136d
addq $-0x61, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1327
incq %r12
jmp 0x1349
movl $0x2, (%r14,%rbx,4)
incl 0x2ccc(%rip)            # 0x404c
addl $0x61, %ebx
leaq 0xc9f(%rip), %rdi       # 0x2029
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/itoa.c
// Function: main
int main(void)
{
  int i = 1234;
  char s[100] = "";

  itoa(s, i);

  printf("itoa: %s\n", s);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andl $0x0, 0x60(%rbx)
movq %rbx, %rdi
movl $0x4d2, %esi            # imm = 0x4D2
callq 0x1198
leaq 0xe7e(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/itoa.c
// Function: itoa
void itoa(char *s, int n)
{
  char *t = s;

  while (n)
  {
    *(t++) = n % 10 + '0';
    n /= 10;
  }

  *t = '\0';

  reverse(s);
}

// Assembly:
movl %esi, %eax
pushq $0xa
popq %rcx
movq %rdi, %rsi
testl %eax, %eax
je 0x11b1
cltd
idivl %ecx
addb $0x30, %dl
movb %dl, (%rsi)
incq %rsi
jmp 0x11a0
movb $0x0, (%rsi)
jmp 0x11b9
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/itoa.c
// Function: reverse
void reverse(char *s)
{
  char *t = s + strlen(s) - 1;
  char aux = 0;

  if (*s == '\0')
    return;

  while (s < t)
  {
    aux = *t;
    *t-- = *s;
    *s++ = aux;
  }
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x11e3
pushq %rbx
movq %rdi, %rbx
callq 0x1030
addq %rbx, %rax
decq %rax
cmpq %rax, %rbx
jae 0x11e2
movb (%rax), %cl
movb (%rbx), %dl
movb %dl, (%rax)
movb %cl, (%rbx)
incq %rbx
decq %rax
jmp 0x11cd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/6-Memory/addr.c
// Function: main
int main(void) {
	int *malloc_ptr = malloc(4);
	char *constant_ptr = "hello";

	printf("Local variable  = %15p\n", &malloc_ptr);
	printf("malloc() space  = %15p\n", malloc_ptr);
	printf("Global variable = %15p\n", &global_int);
	printf("Code & constant = %15p\n", constant_ptr);
	printf("Main            = %15p\n", main);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
pushq $0x4
popq %rdi
callq 0x1040
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0xea2(%rip), %rdi       # 0x200a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
movq (%rbx), %rsi
leaq 0xea6(%rip), %rdi       # 0x2022
xorl %eax, %eax
callq 0x1030
leaq 0xeb0(%rip), %rdi       # 0x203a
leaq 0x2eab(%rip), %rsi      # 0x403c
xorl %eax, %eax
callq 0x1030
leaq 0xeb3(%rip), %rdi       # 0x2052
leaq 0xe5e(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xeb6(%rip), %rdi       # 0x206a
leaq -0x6f(%rip), %rsi       # 0x114c
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/trumabrat[P]GrandProjet/ArbreQuatMain.c
// Function: main
int main(int argc, char const *argv[])
{
    FILE* f = NULL;
    f = fopen("00014_burma.cha", "r");
    Chaines *C = lectureChaines(f);

    Reseau *R = reconstitueReseauArbre(C);
    FILE *f2 = fopen("resArbre.txt", "w");
    ecrireReseau(R, f2);
    afficheReseauSVG(R, "affichage_arbre");

    liberer_chaines(C);
    liberation_reseau(R);
    fclose(f);
    fclose(f2);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xce0(%rip), %rdi       # 0x3343
leaq 0xce9(%rip), %rsi       # 0x3353
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18b0
movq %rax, %r14
movq %rax, %rdi
callq 0x1704
movq %rax, %r15
leaq 0xcc6(%rip), %rdi       # 0x3355
leaq 0xb40(%rip), %rsi       # 0x31d6
callq 0x10e0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x2096
leaq 0xcb2(%rip), %rsi       # 0x3362
movq %r15, %rdi
callq 0x2245
movq %r14, %rdi
callq 0x1d98
movq %r15, %rdi
callq 0x244d
movq %rbx, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: file_put
CONS*
file_put(SINK* sink, CONS* value)
{
	FILE* f;
	int c;
	CONS* ok;

	DBUG_ENTER("file_put");
	assert(numberp(value));
	XDBUG_PRINT("stdout", ("%p", stdout));
	XDBUG_PRINT("stderr", ("%p", stderr));
	XDBUG_PRINT("output_file", ("%p", output_file));
	if (sink->context == MK_REF(output_file)) {
		f = output_file;  /* FIXME: WORKAROUND FOR FILE* ENCODING */
	} else {
		f = (FILE*)(MK_PTR(sink->context));
	}
	XDBUG_PRINT("f", ("%p", f));
	c = MK_INT(value);
	DBUG_PRINT("c", ((isprint(c) ? "%d '%c'" : "%d '\\x%X'"), c, c));
	ok = ((fputc(c, f) == EOF) ? a_false : a_true);
	XDBUG_PRINT("ok", ("%s", cons_to_str(ok)));
	DBUG_RETURN ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19c70(%rip), %rax     # 0x1c004
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21f8f(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x69, 0xc(%rdi)
leaq 0x19f8d(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21d88(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %ebx, %eax
notl %eax
testb $0x3, %al
jne 0x24a9
movq (%r14), %r15
movq 0x21f8d(%rip), %r14     # 0x24378
shrq $0x2, %rbx
leaq 0x2253a(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x2456
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x1b701(%rip), %rdi     # 0x1db0b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2456
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x75, 0xc(%rax)
callq 0x2270
movq (%rax), %rax
movslq %ebx, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xe, %eax
leaq 0x19c0c(%rip), %rax     # 0x1c04c
leaq 0x19bfd(%rip), %rdi     # 0x1c044
cmovaeq %rax, %rdi
movl %ebx, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1b0f0
leaq 0x3(,%r14,4), %rax
movq %r15, %rsi
sarq $0x2, %rsi
cmpq %rax, %r15
cmoveq %r14, %rsi
movl %ebx, %edi
callq 0x2130
cmpl $-0x1, %eax
leaq 0x21f03(%rip), %rax     # 0x24380
leaq 0x21f04(%rip), %rcx     # 0x24388
cmoveq %rax, %rcx
movq (%rcx), %rbx
movq %rsp, %rdi
movl $0x78, 0xc(%rdi)
callq 0x1b1f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x19b5d(%rip), %rdi     # 0x1c00d
leaq 0x19b65(%rip), %rsi     # 0x1c01c
leaq 0x19b67(%rip), %rcx     # 0x1c025
pushq $0x6a
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: generic_put_cstr
CONS*
generic_put_cstr(SINK* sink, char* s)
{
	int c;

	DBUG_ENTER("generic_put_cstr");
	assert(s != NULL);
	DBUG_PRINT("s", ((s ? "\"%s\"" : "NULL"), s));
	while ((c = *s++)) {
		if((sink->put)(sink, NUMBER(c)) == a_false) {
			DBUG_RETURN a_false;
		}
	}
	DBUG_RETURN a_true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19b78(%rip), %rax     # 0x1c056
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21e45(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x7f, 0xc(%rdi)
leaq 0x19e44(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21c3f(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
testq %rbx, %rbx
je 0x25c8
leaq 0x22402(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x256d
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1aff4(%rip), %rdi     # 0x1d535
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x256d
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x81, 0xc(%rax)
leaq 0x19b35(%rip), %rdi     # 0x1c098
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
leaq 0x21e14(%rip), %r15     # 0x24388
leaq 0x21e05(%rip), %r12     # 0x24380
movsbq (%rbx), %rax
testq %rax, %rax
je 0x25a9
incq %rbx
leaq 0x3(,%rax,4), %rsi
movq %r14, %rdi
callq *0x8(%r14)
cmpq 0x21de3(%rip), %rax     # 0x24380
jne 0x257b
movl $0x84, %eax
movq %r12, %r15
jmp 0x25ae
movl $0x87, %eax
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
movq (%r15), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x19a98(%rip), %rdi     # 0x1c067
leaq 0x19a46(%rip), %rsi     # 0x1c01c
leaq 0x19a94(%rip), %rcx     # 0x1c071
movl $0x80, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: file_sink
SINK*
file_sink(FILE* f)
{
	SINK* sink;

	DBUG_ENTER("file_sink");
	DBUG_PRINT("f", ("%p", f));
	sink = NEW(SINK);
	sink->context = MK_REF(f);
	sink->put = file_put;
	sink->put_cstr = generic_put_cstr;
	DBUG_RETURN sink;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x19aa5(%rip), %rax     # 0x1c09d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21d2b(%rip), %r14     # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x8e, 0xc(%rdi)
leaq 0x19d2a(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21b25(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x222f1(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x267e
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x19b19(%rip), %rdi     # 0x1c16b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x267e
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x8f, 0xc(%rax)
leaq 0x1b9ac(%rip), %rdi     # 0x1e020
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
pushq $0x18
popq %rdi
pushq $0x1
popq %rsi
callq 0x2160
movq %rax, %r14
leaq 0x3(,%rbx,4), %rax
movq %rax, (%r14)
leaq -0x322(%rip), %rax      # 0x237c
movq %rax, 0x8(%r14)
leaq -0x1e3(%rip), %rax      # 0x24c6
movq %rax, 0x10(%r14)
movq %rsp, %rdi
movl $0x94, 0xc(%rdi)
callq 0x1b1f2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: string_empty
CONS*
string_empty(SOURCE* src)
{
	char* s;

	DBUG_ENTER("string_empty");
	s = (char*)(MK_PTR(src->context));
	DBUG_PRINT("s", ((s ? "\"%s\"" : "NULL"), s));
	DBUG_RETURN ((s && *s) ? a_false : a_true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x199cd(%rip), %rax     # 0x1c0a7
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x21c47(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xa6, 0xc(%rdi)
leaq 0x19c46(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21a41(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq (%rbx), %r14
movq %r14, %rbx
sarq $0x2, %rbx
leaq 0x22203(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x277b
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1adf5(%rip), %rdi     # 0x1d535
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x277b
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xa8, 0xc(%rax)
cmpq $0x4, %r14
leaq 0x1bf18(%rip), %rax     # 0x1e67e
leaq 0x1992b(%rip), %rdi     # 0x1c098
cmovbq %rax, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
leaq 0x8(%rsp), %rdi
movl $0xa9, 0xc(%rdi)
callq 0x1b1f2
cmpq $0x4, %r14
jb 0x27a0
cmpb $0x0, (%rbx)
je 0x27a0
leaq 0x21be2(%rip), %rax     # 0x24380
jmp 0x27a7
leaq 0x21be1(%rip), %rax     # 0x24388
movq (%rax), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: string_get
CONS*
string_get(SOURCE* src)
{
	char* s;
	int c;

	DBUG_ENTER("string_get");
	if ((src->empty)(src) == a_true) {
		DBUG_PRINT("c", ("EOF"));
		DBUG_RETURN NUMBER(EOF);
	}
	s = (char*)(MK_PTR(src->context));
	c = *s;
	DBUG_PRINT("c", ((isprint(c) ? "%d '%c'" : "%d '\\x%X'"), c, c));
	DBUG_RETURN NUMBER(c);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x198ef(%rip), %rax     # 0x1c0b4
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21b5e(%rip), %r14     # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb1, 0xc(%rdi)
leaq 0x19b5d(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21958(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %rbx, %rdi
callq *0x8(%rbx)
cmpq 0x21b76(%rip), %rax     # 0x24388
je 0x28a0
movq (%rbx), %rax
sarq $0x2, %rax
movsbl (%rax), %eax
movslq %eax, %rbx
leaq 0x22104(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x2887
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1b2cc(%rip), %rdi     # 0x1db0b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2887
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xb8, 0xc(%rax)
callq 0x2270
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
btl $0xe, %eax
leaq 0x197db(%rip), %rax     # 0x1c04c
leaq 0x197cc(%rip), %rdi     # 0x1c044
cmovaeq %rax, %rdi
movl %ebx, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0xb9, 0xc(%rdi)
callq 0x1b1f2
leaq 0x3(,%rbx,4), %rax
jmp 0x28f5
leaq 0x22089(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x28e3
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1b251(%rip), %rdi     # 0x1db0b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x28e3
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xb3, 0xc(%rax)
leaq 0x197e3(%rip), %rdi     # 0x1c0bf
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0xb4, 0xc(%rdi)
callq 0x1b1f2
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq