LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/u_to_buf.c
// Function: u_to_buf
int				u_to_buf(char *buf, t_mod modifiers, va_list ap, int i)
{
	uint64_t	num;
	char		*str;

	if (i == 17)
		modifiers.length = 'z';
	num = convert_length(modifiers.length, ap);
	str = num_string_u_base(num, 10);
	str[0] == '0' && modifiers.prcsn == 0 ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		left_just(buf, str, modifiers, 0);
	else
		right_justify(buf, str, modifiers, 0);
	free(str);
	return (ft_strlen(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
jne 0x115bc
movq -0x30(%rbp), %rax
movl $0x7a, 0x1c(%rax)
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x11680
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x11601
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x11601
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0x11603
jmp 0x11603
movq -0x30(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x1163b
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %edx, %edx
callq 0x118a0
jmp 0x11667
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %edx, %edx
callq 0x11940
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0xbf10
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/u_to_buf.c
// Function: left_just
static void		left_just(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	len = (int)ft_strlen(num);
	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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x18(%rbp), %eax
jle 0x118f9
movq -0x8(%rbp), %rdi
leaq 0x247f(%rip), %rsi      # 0x13d65
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x118c7
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0x107d0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x1192d
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x14(%rbp), %rdx
callq 0x10780
jmp 0x1190d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/u_to_buf.c
// Function: right_justify
static void		right_justify(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	if (mod.neg == 0)
		pos_justify(buf, mod, ft_strlen(num));
	if (mod.prcsn > (len = ft_strlen(num)))
	{
		while ((mod.prcsn--) - len > 0)
		{
			ft_strcpy(buf, "0");
			buf++;
		}
	}
	nbyte = ft_strlen(buf);
	ft_strncpy(buf + nbyte, num, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0x20(%rax)
jne 0x11998
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11a20
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movl %ecx, -0x18(%rbp)
cmpl %ecx, %eax
jle 0x119f1
jmp 0x119ba
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
subl -0x18(%rbp), %eax
cmpl $0x0, %eax
jle 0x119ef
movq -0x8(%rbp), %rdi
leaq 0x2389(%rip), %rsi      # 0x13d65
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x119ba
jmp 0x119f1
movq -0x8(%rbp), %rdi
callq 0xbf10
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0xbb20
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/u_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.space && !nbyte)
	{
		ft_strcpy(buf, " ");
		buf++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl 0xc(%rcx), %eax
movl %eax, 0x20(%rcx)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10820
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $0x0, (%rax)
je 0x11a9c
cmpl $0x0, -0x10(%rbp)
jne 0x11a9c
movq -0x8(%rbp), %rdi
leaq 0x2857(%rip), %rsi      # 0x142e2
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/x_to_buf.c
// Function: x_to_buf
int				x_to_buf(char *buf, t_mod modifiers, va_list ap, int i)
{
	int64_t	num;
	char	*str;
	int		len;

	len = -1;
	num = convert_length(modifiers.length, ap);
	if (modifiers.length == 'l' || modifiers.length / 2 == 'l' ||
		modifiers.length == 'z')
		str = num_string_u_base(num, 16);
	else
		str = ft_uitoa_base(num, 16);
	if (i == 8)
		while (str[++len])
			str[len] = ft_tolower(str[len]);
	str[0] == '0' && modifiers.prcsn == 0 ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		left_justify(buf, str, modifiers, i);
	else
		right_justify(buf, str, modifiers, i);
	free(str);
	return (ft_strlen(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x11c20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
cmpl $0x6c, 0x1c(%rax)
je 0x11b0d
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x6c, %eax
je 0x11b0d
movq -0x38(%rbp), %rax
cmpl $0x7a, 0x1c(%rax)
jne 0x11b21
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
jmp 0x11b35
movq -0x20(%rbp), %rax
movl %eax, %edi
movl $0x10, %esi
callq 0x122b0
movq %rax, -0x28(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x11b75
jmp 0x11b3d
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x11b73
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa370
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x11b3d
jmp 0x11b75
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x11b94
movq -0x38(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x11b94
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0x11b96
jmp 0x11b96
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x11bcf
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11e40
jmp 0x11bfc
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11f50
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0xbf10
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/x_to_buf.c
// Function: left_justify
static void		left_justify(char *buf, char *num, t_mod mod, int capital)
{
	int		len;
	int		count;

	count = 0;
	len = (int)ft_strlen(num);
	if (mod.fl.pound && num[0] != '0' && num[0] != '\0')
	{
		if (capital == 8)
			ft_strcpy(buf, "0x");
		else
			ft_strcpy(buf, "0X");
		buf += 2;
		count += 2;
	}
	while (mod.prcsn-- > len)
	{
		ft_strcpy(buf, "0");
		buf++;
		count++;
	}
	add_to_buf(&buf, num, &count, len);
	while (count < mod.width)
	{
		add_one_to_buf(&buf, ' ', &count);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
cmpl $0x0, 0x4(%rax)
je 0x11ed0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x11ed0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11ed0
cmpl $0x8, -0x14(%rbp)
jne 0x11eab
movq -0x8(%rbp), %rdi
leaq 0x25b7(%rip), %rsi      # 0x1445b
callq 0xbac0
jmp 0x11ebb
movq -0x8(%rbp), %rdi
leaq 0x25b3(%rip), %rsi      # 0x14469
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11ed2
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x18(%rbp), %eax
jle 0x11f0d
movq -0x8(%rbp), %rdi
leaq 0x1e74(%rip), %rsi      # 0x13d65
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11ed2
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
callq 0x107d0
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x11f41
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x1c(%rbp), %rdx
callq 0x10780
jmp 0x11f21
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/x_to_buf.c
// Function: right_justify
static void		right_justify(char *buf, char *num, t_mod mod, int capital)
{
	int		len;

	len = ft_strlen(num);
	if (mod.fl.pound && num[0] != '0' && num[0] != '\0')
	{
		if (mod.fl.fzero && mod.prcsn == -1)
			ft_strcpy(buf, capital == 8 ? "0x" : "0X");
		pos_justify(buf + ft_strlen(buf), mod, len);
		if (!mod.fl.fzero || mod.prcsn > -1)
			ft_strcpy(buf, capital == 8 ? "0x" : "0X");
	}
	else
		pos_justify(buf + ft_strlen(buf), mod, len);
	if (mod.prcsn > len)
		while ((mod.prcsn--) - len > 0)
			ft_strcpy(buf + ft_strlen(buf), "0");
	ft_strncpy(buf + ft_strlen(buf), num, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
cmpl $0x0, 0x4(%rax)
je 0x1204f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x1204f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1204f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x11fdd
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x11fdd
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x249f(%rip), %rsi      # 0x14469
leaq 0x248a(%rip), %rax      # 0x1445b
cmpl $0x8, %ecx
cmoveq %rax, %rsi
callq 0xbac0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rcx
addq %rax, %rdi
movl -0x18(%rbp), %esi
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12110
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1202c
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jle 0x1204d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x242f(%rip), %rsi      # 0x14469
leaq 0x241a(%rip), %rax      # 0x1445b
cmpl $0x8, %ecx
cmoveq %rax, %rsi
callq 0xbac0
jmp 0x1208a
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
addq %rax, %rdi
movl -0x18(%rbp), %esi
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12110
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0x120d7
jmp 0x12098
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
subl -0x18(%rbp), %eax
cmpl $0x0, %eax
jle 0x120d5
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x38(%rbp), %rdi
addq %rax, %rdi
leaq 0x1c97(%rip), %rsi      # 0x13d65
callq 0xbac0
jmp 0x12098
jmp 0x120d7
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x40(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0xbb20
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl 0xc(%rcx), %eax
movl %eax, 0x20(%rcx)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10820
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
jne 0x12196
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12196
cmpl $0x0, -0x10(%rbp)
jne 0x12196
movq -0x8(%rbp), %rdi
leaq 0x215d(%rip), %rsi      # 0x142e2
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movslq -0xc(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x121cf
leaq 0x22ad(%rip), %rdi      # 0x1446e
callq 0xc1d0
movq %rax, -0x8(%rbp)
jmp 0x12299
cmpl $0x0, -0xc(%rbp)
jge 0x121de
imull $-0x1, -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x121e0
jmp 0x121e0
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x12209
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x121ed
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0xa, -0x10(%rbp)
jne 0x12220
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12222
jmp 0x12222
movslq -0x18(%rbp), %rdi
callq 0xc020
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1223f
movq $0x0, -0x8(%rbp)
jmp 0x12299
jmp 0x12241
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x1227e
movl -0x14(%rbp), %eax
cltd
idivl -0x10(%rbp)
movslq %edx, %rcx
leaq 0x221e(%rip), %rax      # 0x14480
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
jmp 0x12241
cmpl $0x0, -0xc(%rbp)
jge 0x12291
cmpl $0xa, -0x10(%rbp)
jne 0x12291
movq -0x20(%rbp), %rax
movb $0x2d, (%rax)
movq -0x20(%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/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x122e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x122cb
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x18(%rbp), %rdi
callq 0xc020
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1230b
movq $0x0, -0x8(%rbp)
jmp 0x12355
jmp 0x1230d
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x1234d
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0x10(%rbp)
movl %edx, %eax
movl %eax, %ecx
leaq 0x2150(%rip), %rax      # 0x14480
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, -0x14(%rbp)
jmp 0x1230d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x1238c
leaq 0x20f0(%rip), %rdi      # 0x1446e
callq 0xc1d0
movq %rax, -0x8(%rbp)
jmp 0x12428
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x123ad
imull $-0x1, -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0xbed0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0xc020
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x123d8
movq $0x0, -0x8(%rbp)
jmp 0x12428
jmp 0x123da
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x12413
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
jmp 0x123da
cmpl $0x0, -0xc(%rbp)
jge 0x12420
movq -0x20(%rbp), %rax
movb $0x2d, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0xda2(%rip), %rdi       # 0x2004
callq 0x1030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1294
movq 0x2d7f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd8b(%rip), %rsi       # 0x200e
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1140
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x12ea
movq 0x2d46(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x90(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1110
movq -0x90(%rbp), %rdi
movq %rax, %rdx
leaq 0xd50(%rip), %rsi       # 0x2029
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
leaq -0x7a(%rbp), %rdi
xorl %esi, %esi
movl $0x6e, %edx
callq 0x1090
movw $0x1, -0x7a(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1080
addq $0x1, %rax
cmpq $0x6c, %rax
jbe 0x1335
movq 0x2cde(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd2a(%rip), %rsi       # 0x204e
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
leaq -0x7a(%rbp), %rdi
addq $0x2, %rdi
movq -0x8(%rbp), %rsi
callq 0x1060
movl -0xc(%rbp), %edi
leaq -0x7a(%rbp), %rsi
movl $0x6e, %edx
callq 0x10f0
cmpl $-0x1, %eax
jne 0x139b
movq 0x2c95(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x98(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1110
movq -0x98(%rbp), %rdi
movq %rax, %rdx
leaq 0xce5(%rip), %rsi       # 0x206f
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
movl -0xc(%rbp), %edi
leaq 0xce9(%rip), %rsi       # 0x208e
callq 0x10d0
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x13dd
movq 0x2c36(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcc5(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x1130
cmpq $-0x1, %rax
jne 0x1447
movq 0x2bcc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc83(%rip), %rsi       # 0x20b9
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0x178b
movq 0x2888(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x960(%rip), %rsi       # 0x20da
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x10e0
movl $0x206574, -0x1d(%rbp)  # imm = 0x206574
movl $0x74617473, -0x20(%rbp) # imm = 0x74617473
leaq -0x20(%rbp), %rdi
callq 0x1080
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1080
movq -0x50(%rbp), %rcx
leaq 0x2(%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rsp, %rax
movq %rax, -0x30(%rbp)
movq %rcx, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x48(%rbp)
movq %rax, %rsp
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1060
leaq -0x20(%rbp), %rdi
callq 0x1080
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1060
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1080
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb $0x20, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1060
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1100
cmpq $0x1, %rax
je 0x18a9
movq 0x276a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x863(%rip), %rsi       # 0x20fb
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movabsq $0x2f642e74696e69, %rax # imm = 0x2F642E74696E69
movq %rax, -0x23(%rbp)
movabsq $0x696e692f6374652f, %rax # imm = 0x696E692F6374652F
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1080
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1080
movq -0x68(%rbp), %rcx
movq %rax, %rdx
leaq 0x1(%rcx,%rdx), %rax
movq %rsp, %rsi
movq %rsi, -0x30(%rbp)
leaq 0x10(%rcx,%rdx), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x60(%rbp)
movq %rdi, %rsp
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x1060
leaq -0x28(%rbp), %rdi
callq 0x1080
movq -0x60(%rbp), %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x1060
movq -0x60(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x1120
movq 0x2462(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1110
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x5cf(%rip), %rsi       # 0x2186
movb $0x0, %al
callq 0x10b0
movl $0x41, %edi
callq 0x10e0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
je 0x1c0b
movq 0x2408(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x4e0(%rip), %rsi       # 0x20da
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x581(%rip), %rsi       # 0x219e
callq 0x1ad0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
je 0x1c6b
movq 0x23a8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x480(%rip), %rsi       # 0x20da
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x528(%rip), %rsi       # 0x21a5
callq 0x1ad0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x118, %rsp            # imm = 0x118
movl $0x0, 0x114(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x2c0f(%rip), %rsi      # 0x3da0
movl $0x40, %edx
callq 0x1050
movl $0x0, 0xac(%rsp)
cmpl $0x8, 0xac(%rsp)
jge 0x11d6
movslq 0xac(%rsp), %rax
movl $0x0, 0xb0(%rsp,%rax,4)
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x11a6
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
movl $0x8, %esi
movl $0x1, %ecx
callq 0x1340
movl $0x0, 0x1c(%rsp)
cmpl $0x8, 0x1c(%rsp)
jge 0x123c
movl $0x9, %edi
callq 0x1060
movq %rax, %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0x60(%rsp,%rax,8)
movslq 0x1c(%rsp), %rax
movq 0x60(%rsp,%rax,8), %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0x20(%rsp,%rax,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11fd
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x12bd
movslq 0x18(%rsp), %rax
movq 0xd0(%rsp,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x12ae
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
movl %eax, 0xc(%rsp)
movl 0x18(%rsp), %eax
addl $0x61, %eax
movb %al, %cl
movslq 0xc(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rax
movb %cl, (%rax)
movslq 0xc(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x125d
jmp 0x12b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1244
movl $0x0, 0x8(%rsp)
cmpl $0x8, 0x8(%rsp)
jge 0x12e6
movslq 0x8(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rax
movb $0x0, (%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x12c5
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
movl $0x8, %esi
movl $0x2, %ecx
callq 0x1340
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x132d
movslq 0x4(%rsp), %rax
movq 0x60(%rsp,%rax,8), %rdi
callq 0x1030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x130a
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x1, -0x24(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13ad
movq -0x40(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x138b
movl -0x1c(%rbp), %esi
leaq 0xc5f(%rip), %rdi       # 0x2016
movb $0x0, %al
callq 0x1040
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rdx
callq 0x1440
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jl 0x1423
cmpl $0x2, -0x1c(%rbp)
jne 0x13f5
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
leaq 0xc33(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1040
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %r8d
callq 0x14c0
cmpl $0x2, -0x1c(%rbp)
jne 0x1421
leaq 0xc05(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1040
jmp 0x13be
leaq 0xbf5(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1040
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/graph.c
// Function: dfs_next_vertex
static int dfs_next_vertex(int n, int color[], int ft[])
{
	/* Pick max ft[] */
	int maxft = -1;
	int v = -1;
	for (int i = 0; i < n; i++) {
		if (color[i] == WHITE && ft[i] > maxft) {
			maxft = ft[i];
			v = i;
		}
	}
	return v;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0xffffffff, -0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x14bb
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x14ac
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rsp), %eax
jle 0x14ac
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x14ae
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1466
movl -0x20(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl 0x2b6a(%rip), %eax      # 0x404c
addl $0x1, %eax
movl %eax, 0x2b61(%rip)      # 0x404c
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl $0x1, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1565
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1555
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x14c0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x150f
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl $0x2, (%rax,%rcx,4)
movl 0x2ad0(%rip), %eax      # 0x404c
addl $0x1, %eax
movl %eax, 0x2ac7(%rip)      # 0x404c
movl 0x14(%rsp), %esi
addl $0x61, %esi
leaq 0xa96(%rip), %rdi       # 0x2029
movb $0x0, %al
callq 0x1040
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0x4d2, -0x8(%rbp)      # imm = 0x4D2
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x1050
leaq -0x70(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x11b0
leaq -0x70(%rbp), %rsi
leaq 0xe67(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x11fe
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x11c7
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1261
jmp 0x12a3
jmp 0x1263
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x12a3
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x1263
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x4, %edi
callq 0x1040
movq %rax, -0x10(%rbp)
leaq 0xe90(%rip), %rax       # 0x2004
movq %rax, -0x18(%rbp)
leaq 0xe8b(%rip), %rdi       # 0x200a
leaq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0xe8d(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1030
leaq 0xe97(%rip), %rdi       # 0x203a
leaq 0x2e92(%rip), %rsi      # 0x403c
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rsi
leaq 0xe96(%rip), %rdi       # 0x2052
movb $0x0, %al
callq 0x1030
leaq 0xea0(%rip), %rdi       # 0x206a
leaq -0x81(%rip), %rsi       # 0x1150
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xb16(%rip), %rdi       # 0x432b
leaq 0xb1f(%rip), %rsi       # 0x433b
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d30
movq %rax, -0x28(%rbp)
leaq 0xaf7(%rip), %rdi       # 0x433d
leaq 0x961(%rip), %rsi       # 0x41ae
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2de0
movq -0x28(%rbp), %rdi
leaq 0xadc(%rip), %rsi       # 0x434a
callq 0x3070
movq -0x20(%rbp), %rdi
callq 0x2810
movq -0x28(%rbp), %rdi
callq 0x3400
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x30(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x26c8d(%rip), %rax     # 0x29004
movq %rax, -0x50(%rbp)
leaq 0x2cf9e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x69, -0x44(%rbp)
leaq 0x26fd2(%rip), %rax     # 0x2936f
movq %rax, -0x40(%rbp)
leaq 0x2cd98(%rip), %rax     # 0x2f140
movq %rax, -0x38(%rbp)
leaq 0x2cf6d(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x3, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x23e5
jmp 0x2404
leaq 0x26c21(%rip), %rdi     # 0x2900d
leaq 0x26c29(%rip), %rsi     # 0x2901c
movl $0x6a, %edx
leaq 0x26c26(%rip), %rcx     # 0x29025
callq 0x2100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x2cf56(%rip), %rcx     # 0x2f368
shlq $0x2, %rcx
orq $0x3, %rcx
cmpq %rcx, %rax
jne 0x242c
movq 0x2cf42(%rip), %rax     # 0x2f368
movq %rax, -0x18(%rbp)
jmp 0x243b
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
sarq $0x2, %rax
movl %eax, -0x1c(%rbp)
leaq 0x2d4d3(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x24c9
leaq 0x2cec7(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x286bd(%rip), %rcx     # 0x2ab24
movq %rcx, 0x10(%rax)
leaq 0x286b2(%rip), %rdi     # 0x2ab24
callq 0x278a0
cmpl $0x0, %eax
je 0x24c9
leaq 0x2ce9d(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x75, 0xc(%rax)
callq 0x2250
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x4000, %ecx           # imm = 0x4000
leaq 0x26b9e(%rip), %rdi     # 0x2904c
leaq 0x26b8f(%rip), %rax     # 0x29044
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movl -0x1c(%rbp), %esi
movl -0x1c(%rbp), %edx
movb $0x0, %al
callq 0x28540
jmp 0x24cb
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $-0x1, %eax
jne 0x24e9
movq 0x2ce8d(%rip), %rax     # 0x2f370
movq %rax, -0x58(%rbp)
jmp 0x24f4
movq 0x2ce88(%rip), %rax     # 0x2f378
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x78, -0x44(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x28660
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x26b1f(%rip), %rax     # 0x29056
movq %rax, -0x48(%rbp)
leaq 0x2cdde(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x7f, -0x3c(%rbp)
leaq 0x26e12(%rip), %rax     # 0x2936f
movq %rax, -0x38(%rbp)
leaq 0x2cbd8(%rip), %rax     # 0x2f140
movq %rax, -0x30(%rbp)
leaq 0x2cdad(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28490
cmpq $0x0, -0x18(%rbp)
je 0x2590
jmp 0x25af
leaq 0x26ad0(%rip), %rdi     # 0x29067
leaq 0x26a7e(%rip), %rsi     # 0x2901c
movl $0x80, %edx
leaq 0x26ac7(%rip), %rcx     # 0x29071
callq 0x2100
jmp 0x25b1
leaq 0x2d368(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2621
leaq 0x2cd5c(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x27f94(%rip), %rcx     # 0x2a566
movq %rcx, 0x10(%rax)
leaq 0x27f89(%rip), %rdi     # 0x2a566
callq 0x278a0
cmpl $0x0, %eax
je 0x2621
leaq 0x2cd32(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x81, 0xc(%rax)
movq -0x18(%rbp), %rcx
leaq 0x29113(%rip), %rdi     # 0x2b71a
leaq 0x26a8a(%rip), %rax     # 0x29098
cmpq $0x0, %rcx
cmovneq %rax, %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x28540
jmp 0x2623
jmp 0x2625
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x2681
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x2, %rsi
orq $0x3, %rsi
callq *%rax
cmpq 0x2cd10(%rip), %rax     # 0x2f370
jne 0x267f
movl $0x84, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movq 0x2ccf7(%rip), %rax     # 0x2f370
movq %rax, -0x8(%rbp)
jmp 0x269c
jmp 0x2625
movl $0x87, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movq 0x2cce0(%rip), %rax     # 0x2f378
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)