LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock2.c
// Function: ft_flags_stock2_2
void	ft_flags_stock2_2(t_var *var, t_flags *s_flags, char *str_hexa)
{
	int	i;
	int	x;

	x = 0;
	i = s_flags->largeur - s_flags->precision - var->len_str_hexa;
	if ((var->type >= TYPE_OCTAL && var->type <= TYPE_HEXA_MAJ) &&
	(!s_flags->precision || s_flags->c & (1 << 4)))
		x = var->len_str_hexa;
	if (s_flags->largeur < var->len_str_hexa)
		var->i_moins = ft_stock_moins(var, str_hexa);
	(str_hexa[0] == '-') ? var->i_moins = 1 : 0;
	var->i_plus = (s_flags->c & (1 << 1)) ? 1 : 0;
	var->k = ((var->type == TYPE_HEXA || var->type == TYPE_HEXA_MAJ) &&
	(s_flags->c & (1 << 0)) && i >= s_flags->largeur) ? i :
s_flags->largeur - s_flags->precision - var->i_moins - var->i_plus - x;
	(var->k < 0) ? var->k = 0 : 0;
	ft_memset(&var->buf_tmp[var->i_buf_tmp], ' ', var->k);
	var->i_buf_tmp += var->k;
	if (!(s_flags->largeur < var->len_str_hexa))
		var->i_moins = ft_stock_moins(var, str_hexa);
	ft_split2_2(s_flags, var, str_hexa);
	var->i_buf_tmp += var->len_str_hexa;
	ft_memcpy(&var->buf[var->i_buf], var->buf_tmp, var->i_buf_tmp +
			var->len_str_hexa);
	var->i_buf += s_flags->largeur;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %ebp
movl 0x8(%rsi), %r13d
movl 0x78(%rdi), %eax
movl 0x88(%rdi), %r15d
addl $-0xb, %eax
xorl %r12d, %r12d
cmpl $0x3, %eax
ja 0x3951
testl %r13d, %r13d
je 0x394e
testb $0x10, (%r14)
je 0x3951
movl %r15d, %r12d
cmpl %r15d, %ebp
jge 0x3968
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4da8
movl %eax, 0x80(%rbx)
movq (%rsp), %rax
cmpb $0x2d, (%rax)
jne 0x397b
movl $0x1, 0x80(%rbx)
movl (%r14), %edx
movl %edx, %eax
shrl %eax
andl $0x1, %eax
movl %eax, 0x7c(%rbx)
movl 0x78(%rbx), %esi
addl $-0xf, %esi
movl 0x4(%r14), %ecx
cmpl $-0x2, %esi
jb 0x39a6
andb $0x1, %dl
je 0x39a6
addl %r15d, %r13d
subl %r13d, %ebp
cmpl %ecx, %ebp
jge 0x39b9
addl %eax, %r12d
addl 0x8(%r14), %r12d
addl 0x80(%rbx), %r12d
subl %r12d, %ecx
movl %ecx, %ebp
xorl %edx, %edx
testl %ebp, %ebp
cmovgl %ebp, %edx
movl %edx, 0x90(%rbx)
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
movl $0x20, %esi
callq 0x40e8
movl 0x90(%rbx), %eax
addl %eax, 0x64(%rbx)
movl 0x4(%r14), %eax
cmpl 0x88(%rbx), %eax
jl 0x39ff
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4da8
movl %eax, 0x80(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x3d20
movl 0x88(%rbx), %eax
movl 0x64(%rbx), %ecx
addl %eax, %ecx
movl %ecx, 0x64(%rbx)
movslq 0x60(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
addl %eax, %ecx
movslq %ecx, %rdx
callq 0x4108
movl 0x4(%r14), %eax
addl %eax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock2.c
// Function: ft_flags_stock2_21
void	ft_flags_stock2_21(t_var *var, t_flags *s_flags, char *str_hexa)
{
	var->i_plus = ft_stock_plus(var, s_flags, str_hexa);
	var->k = s_flags->precision - var->len_str_hexa;
	(var->k < 0) ? var->k = 0 : 0;
	ft_memset(&var->buf_tmp[var->i_buf_tmp], '0', var->k);
	var->i_buf_tmp += var->k;
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], str_hexa,
	var->len_str_hexa);
	var->i_buf_tmp += var->len_str_hexa;
	var->k = ((var->type == TYPE_HEXA || var->type == TYPE_HEXA_MAJ) &&
	var->len_str_hexa) ? s_flags->largeur - s_flags->precision
	: s_flags->largeur - s_flags->precision;
	ft_memset(&var->buf_tmp[var->i_buf_tmp], ' ', var->k);
	var->i_buf_tmp += var->k;
	(!var->len_str_hexa && !s_flags->precision && (var->type >=
			TYPE_OCTAL && var->type <= TYPE_OCTAL_MAJ)) ?
		ft_memcpy(&var->buf[var->i_buf++], "0", 1) : 0;
	ft_memcpy(&var->buf[var->i_buf], var->buf_tmp,
	var->i_buf_tmp + var->len_str_hexa);
	var->i_buf += s_flags->largeur;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x368c
movl %eax, 0x7c(%rbx)
movl 0x8(%r14), %edx
subl 0x88(%rbx), %edx
xorl %ebp, %ebp
testl %edx, %edx
cmovlel %ebp, %edx
movl %edx, 0x90(%rbx)
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
movl $0x30, %esi
callq 0x40e8
movslq 0x90(%rbx), %rax
movslq 0x64(%rbx), %rdi
addq %rax, %rdi
movl %edi, 0x64(%rbx)
addq 0x10(%rbx), %rdi
movslq 0x88(%rbx), %rdx
movq %r15, %rsi
callq 0x4108
movslq 0x88(%rbx), %rax
movslq 0x64(%rbx), %rdi
addq %rax, %rdi
movl %edi, 0x64(%rbx)
movslq 0x4(%r14), %rdx
movslq 0x8(%r14), %rax
subq %rax, %rdx
movl %edx, 0x90(%rbx)
addq 0x10(%rbx), %rdi
movl $0x20, %esi
callq 0x40e8
movl 0x64(%rbx), %eax
movl 0x88(%rbx), %ecx
addl 0x90(%rbx), %eax
movl %eax, 0x64(%rbx)
testl %ecx, %ecx
je 0x3af7
movl %ecx, %ebp
jmp 0x3b31
cmpl $0x0, 0x8(%r14)
jne 0x3b31
movl 0x78(%rbx), %ecx
addl $-0xb, %ecx
cmpl $0x1, %ecx
ja 0x3b31
movslq 0x60(%rbx), %rdi
leal 0x1(%rdi), %eax
movl %eax, 0x60(%rbx)
addq 0x8(%rbx), %rdi
leaq 0x16b2(%rip), %rsi      # 0x51d0
movl $0x1, %edx
callq 0x4108
movl 0x64(%rbx), %eax
movl 0x88(%rbx), %ebp
addl %eax, %ebp
movslq 0x60(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movslq %ebp, %rdx
callq 0x4108
movl 0x4(%r14), %eax
addl %eax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock2.c
// Function: ft_flags_stock2_1
void	ft_flags_stock2_1(t_var *var, t_flags *s_flags, char *str_hexa)
{
	var->i_moins = ft_stock_moins(var, str_hexa);
	ft_stock_buf_base(var, s_flags, var->res_strcmp);
	var->k = s_flags->precision - var->len_str_hexa + var->i_moins;
	(var->k < 0) ? var->k = 0 : 0;
	ft_memset(&var->buf_tmp[var->i_buf_tmp], '0', var->k);
	var->i_buf_tmp += var->k;
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], &str_hexa[var->i_moins],
	var->len_str_hexa);
	ft_memcpy(&var->buf[var->i_buf], var->buf_tmp, var->i_buf_tmp +
	var->len_str_hexa);
	var->i_buf += var->i_buf_tmp + var->len_str_hexa - var->i_moins;
	(!var->len_str_hexa && !s_flags->precision && (var->type >= TYPE_OCTAL
	&& var->type <= TYPE_HEXA_MAJ)) ?
	ft_memcpy(&var->buf[var->i_buf++], "0", 1) : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x4da8
movl %eax, 0x80(%rbx)
movl 0x8c(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3561
movl 0x8(%r14), %eax
subl 0x88(%rbx), %eax
addl 0x80(%rbx), %eax
xorl %edx, %edx
testl %eax, %eax
cmovgl %eax, %edx
movl %edx, 0x90(%rbx)
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
movl $0x30, %esi
callq 0x40e8
movslq 0x90(%rbx), %rax
movslq 0x64(%rbx), %rdi
addq %rax, %rdi
movl %edi, 0x64(%rbx)
addq 0x10(%rbx), %rdi
movslq 0x80(%rbx), %rsi
addq %r15, %rsi
movslq 0x88(%rbx), %rdx
callq 0x4108
movslq 0x60(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movslq 0x64(%rbx), %rax
movslq 0x88(%rbx), %rdx
addq %rax, %rdx
callq 0x4108
movl 0x88(%rbx), %eax
movl 0x64(%rbx), %ecx
addl %eax, %ecx
subl 0x80(%rbx), %ecx
movslq 0x60(%rbx), %rdx
movslq %ecx, %rdi
addq %rdx, %rdi
movl %edi, 0x60(%rbx)
testl %eax, %eax
jne 0x3c53
cmpl $0x0, 0x8(%r14)
jne 0x3c53
movl 0x78(%rbx), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x3c53
leal 0x1(%rdi), %eax
movl %eax, 0x60(%rbx)
addq 0x8(%rbx), %rdi
leaq 0x158c(%rip), %rsi      # 0x51d0
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x4108
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_verif_buf.c
// Function: ft_verif_buf
void	ft_verif_buf(t_var *var, const char *format)
{
	if (var->i_buf > 10000)
	{
		write(1, var->buf, 10000);
		var->i_buf = 0;
		ft_bzero(var->buf, 10000);
	}
	var->ret += ft_stock_flags(&((char*)format)[var->ret], var);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2711, 0x60(%rdi)     # imm = 0x2711
jl 0x3c97
movq 0x8(%rbx), %rsi
movl $0x2710, %edx           # imm = 0x2710
movl $0x1, %edi
callq 0x1040
movl $0x0, 0x60(%rbx)
movq 0x8(%rbx), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x40f8
movslq 0x5c(%rbx), %rax
addq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4855
addl %eax, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_verif_flags_stock2_4.c
// Function: ft_verif_flags_stock2_4
int		ft_verif_flags_stock2_4(t_flags *s_flags, t_var *var)
{
	int	i;

	i = 0;
	if (s_flags->c & (1 << 3) && (var->type == TYPE_SHORT ||
		var->type == TYPE_INT || var->type == TYPE_SHORT_MAJ))
	{
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], " ", 1);
		var->i_buf_tmp += ++i;
	}
	return (i);
}

// Assembly:
xorl %eax, %eax
testb $0x8, (%rdi)
je 0x3d1c
pushq %rbx
movq %rsi, %rbx
movl 0x78(%rsi), %ecx
addl $-0x6, %ecx
cmpl $0x2, %ecx
ja 0x3d1b
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x14cc(%rip), %rsi      # 0x51d5
movl $0x1, %edx
callq 0x4108
incl 0x64(%rbx)
movl $0x1, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_split2_2.c
// Function: ft_split2_2
void	ft_split2_2(t_flags *s_flags, t_var *var, char *str_hexa)
{
	ft_stock_plus(var, s_flags, str_hexa);
	ft_stock_buf_base(var, s_flags, var->res_strcmp);
	var->k = s_flags->precision - var->len_str_hexa + var->i_moins;
	ft_memset(&var->buf_tmp[var->i_buf_tmp], '0', var->k);
	var->i_buf_tmp += var->k;
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], &str_hexa[var->i_moins],
			var->len_str_hexa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x368c
movl 0x8c(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3561
movslq 0x8(%r15), %rax
movslq 0x88(%rbx), %rcx
subq %rcx, %rax
movslq 0x80(%rbx), %rdx
addq %rax, %rdx
movl %edx, 0x90(%rbx)
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
movl $0x30, %esi
callq 0x40e8
movslq 0x90(%rbx), %rax
movslq 0x64(%rbx), %rdi
addq %rax, %rdi
movl %edi, 0x64(%rbx)
addq 0x10(%rbx), %rdi
movslq 0x80(%rbx), %rsi
addq %r14, %rsi
movslq 0x88(%rbx), %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4108
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_split2_5.c
// Function: ft_split2_5
void	ft_split2_5(t_flags *s_flags, t_var *var)
{
	if (var->type == TYPE_ADDRESS)
		var->k = s_flags->largeur - var->len_str_hexa - 2;
	else if (s_flags->precision < var->len_str_hexa && var->res_strcmp)
		var->k = s_flags->largeur - var->len_str_hexa;
	else if ((s_flags->largeur >= s_flags->precision + var->len_str_hexa &&
		var->res_strcmp && var->type != TYPE_BITWISE) ||
		s_flags->precision >= var->len_str_hexa)
		var->k = s_flags->largeur - s_flags->precision - var->len_str_hexa;
	else
		var->k = s_flags->largeur - s_flags->precision;
}

// Assembly:
movl 0x78(%rsi), %r8d
movl 0x88(%rsi), %edx
cmpl $0xf, %r8d
jne 0x3dc6
movl 0x4(%rdi), %eax
subl %edx, %eax
addl $-0x2, %eax
jmp 0x3e12
movl 0x8(%rdi), %ecx
cmpl %edx, %ecx
jl 0x3dd9
movl 0x4(%rdi), %eax
leal (%rdx,%rcx), %edi
cmpl %edi, %eax
jge 0x3df0
jmp 0x3e10
cmpl $0x0, 0x8c(%rsi)
movl 0x4(%rdi), %eax
je 0x3de9
subl %edx, %eax
jmp 0x3e12
leal (%rdx,%rcx), %edi
cmpl %edi, %eax
jl 0x3e0c
cmpl $0x0, 0x8c(%rsi)
setne %r9b
cmpl $0x12, %r8d
setne %r8b
cmpl %edx, %ecx
jge 0x3e10
andb %r9b, %r8b
jne 0x3e10
subl %ecx, %eax
jmp 0x3e12
subl %edi, %eax
movl %eax, 0x90(%rsi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_init_var.c
// Function: ft_init_var
void	ft_init_var(t_var *var)
{
	var->buf = (char *)malloc(sizeof(char) * 10000);
	var->buf_tmp = (char *)malloc(sizeof(char) * 10000);
	var->ret = 0;
	var->i_buf = 0;
	var->nb_conv = 0;
	ft_strcpy(var->flags_conv, "cCdDioOuUxXpsSb");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2710, %edi           # imm = 0x2710
callq 0x10b0
movq %rax, 0x8(%rbx)
movl $0x2710, %edi           # imm = 0x2710
callq 0x10b0
movq %rax, 0x10(%rbx)
movq $0x0, 0x5c(%rbx)
movl $0x0, 0x98(%rbx)
addq $0x4a, %rbx
leaq 0x12c4(%rip), %rsi      # 0x5135
movq %rbx, %rdi
popq %rbx
jmp 0x3f3c
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int	i;

	i = 0;
	while (s1[i] || s2[i])
	{
		if (s1[i] != s2[i])
			return ((unsigned char)s1[i] - (unsigned char)s2[i]);
		i++;
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
xorl %edx, %edx
movzbl (%rdi,%rdx), %ecx
movb (%rsi,%rdx), %r8b
movl %ecx, %r9d
orb %r8b, %r9b
je 0x3f04
incq %rdx
cmpb %r8b, %cl
je 0x3ee4
movzbl %r8b, %eax
subl %eax, %ecx
movl %ecx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(char *s1)
{
	int		i;
	char	*str;

	i = 0;
	if ((str = (char *)malloc(sizeof(*str) * ft_strlen(s1) + 1)) == NULL)
		return (NULL);
	while (s1[i])
	{
		str[i] = s1[i];
		i++;
	}
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3ecc
leaq 0x1(%rax), %rdi
callq 0x10b0
testq %rax, %rax
je 0x3f37
movb (%rbx), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x3f33
movb %dl, (%rax,%rcx)
movb 0x1(%rbx,%rcx), %dl
incq %rcx
jmp 0x3f23
movb $0x0, (%rax,%rcx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_strcat.c
// Function: ft_strcat
char	*ft_strcat(char *s1, const char *s2)
{
	int		i;
	int		j;

	i = 0;
	j = ft_strlen(s1);
	while (s2[i])
	{
		s1[j] = s2[i];
		j++;
		i++;
	}
	s1[j] = '\0';
	return (s1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3ecc
movb (%r14), %cl
testb %cl, %cl
je 0x3f83
cltq
incq %r14
movb %cl, (%rbx,%rax)
incq %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x3f73
cltq
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_strstr.c
// Function: ft_strstr
char	*ft_strstr(const char *haystack, const char *needle)
{
	int		i;

	if (ft_strcmp(haystack, needle) == 0)
		return ((char*)haystack);
	if (haystack[0])
	{
		i = 0;
		while (needle[i])
		{
			if (needle[i] != haystack[i])
				return (ft_strstr((char*)haystack + 1, needle));
			i = i + 1;
		}
		return ((char*)haystack);
	}
	else
		return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3ee0
testl %eax, %eax
je 0x3fd8
cmpb $0x0, (%rbx)
je 0x3fd6
movb (%r14), %cl
testb %cl, %cl
je 0x3fd8
movl $0x1, %eax
cmpb -0x1(%rbx,%rax), %cl
jne 0x3fcb
movb (%r14,%rax), %cl
incq %rax
testb %cl, %cl
jne 0x3fb8
jmp 0x3fd8
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x3f9e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_atoi.c
// Function: ft_atoi
int			ft_atoi(const char *str)
{
	int		i;
	int		k;
	int		res;

	i = 0;
	res = 0;
	k = 0;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' ||
		str[i] == '\r' || str[i] == '\v' || str[i] == '\f')
		i++;
	if (str[i] == '-')
	{
		i++;
		k = 1;
	}
	else if (str[i] == '+')
	{
		i++;
		k = 0;
	}
	while (str[i] >= '0' && str[i] <= '9')
		res = res * 10 + (str[i++] - 48);
	(k == 1) ? res = res * -1 : res;
	return (res);
}

// Assembly:
leaq 0x1(%rdi), %rax
xorl %edx, %edx
movb -0x1(%rax), %cl
movzbl %cl, %esi
leal -0x9(%rsi), %r8d
cmpl $0x5, %r8d
jae 0x402a
incq %rdx
incq %rax
jmp 0x4012
cmpl $0x20, %esi
je 0x4022
leal -0x2b(%rcx), %r8d
andb $-0x3, %r8b
cmpb $0x1, %r8b
adcl $0x0, %edx
movb (%rdi,%rdx), %dl
leal -0x30(%rdx), %edi
xorl %esi, %esi
cmpb $0x9, %dil
ja 0x4070
cmpb $0x1, %r8b
adcq $0x0, %rax
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rsi,2), %esi
movb (%rax), %dl
leal -0x30(%rdx), %edi
incq %rax
cmpb $0xa, %dil
jb 0x4056
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_strnequ.c
// Function: ft_strnequ
int			ft_strnequ(char const *s1, char const *s2, size_t n)
{
	size_t	i;

	i = 0;
	if (s1 == 0)
		return (0);
	if (s2 == 0)
		return (0);
	while (i < n && (s1[i] || s2[i]))
	{
		if (s1[i] != s2[i])
			return (0);
		i++;
	}
	return (1);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x40bb
xorl %eax, %eax
retq
movl $0x1, %eax
testq %rdx, %rdx
je 0x40e4
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
movb (%rsi,%rcx), %r9b
movl %r8d, %r10d
orb %r9b, %r10b
je 0x40e4
cmpb %r9b, %r8b
jne 0x40b8
incq %rcx
cmpq %rcx, %rdx
jne 0x40c7
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	size_t	i;

	i = 0;
	while (i < n)
	{
		((unsigned char *)dst)[i] = ((unsigned char *)src)[i];
		i++;
	}
	return (dst);
}

// Assembly:
movq %rdi, %rax
testq %rdx, %rdx
je 0x4122
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x4112
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	int		i;
	int		cpy;
	int		flg;
	char	*str;

	if (n == -2147483648)
		return (str = ft_lol());
	i = 0;
	flg = ABS(n);
	n = (flg == 0) ? n : n * -1;
	cpy = n;
	i = ft_count(cpy);
	(flg == 1) ? i++ : i;
	if ((str = (char *)malloc(sizeof(*str) * i + 1 + flg)) == 0)
		return (0);
	if (n == 0)
		str[0] = '0';
	str[i--] = '\0';
	str = ft_print(str, n, &i);
	if (flg == 1)
		str[i] = '-';
	return (str);
}

// Assembly:
movl %edi, %eax
negl %eax
jno 0x4136
leaq 0x10a6(%rip), %rdi      # 0x51d7
jmp 0x3f08
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, %ebp
negl %ebp
cmovsl %edi, %ebp
movl $0x1, %ecx
cmpl $0xa, %ebp
jb 0x416c
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ebp, %esi
movl %esi, %edi
imulq %rdx, %rdi
shrq $0x23, %rdi
incl %ecx
cmpl $0x63, %esi
movl %edi, %esi
ja 0x4159
addl %eax, %ecx
movslq %ecx, %r14
movl %eax, %eax
leaq (%rax,%r14), %rdi
incq %rdi
callq 0x10b0
testq %rax, %rax
je 0x41e9
testl %ebx, %ebx
je 0x41ed
leal -0x1(%r14), %ecx
movb $0x0, (%rax,%r14)
movslq %ecx, %rcx
movq %rax, %rdx
addq %rcx, %rdx
shlq $0x20, %rcx
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
addq %rdi, %rcx
movl %ebp, %r8d
imulq %rsi, %r8
shrq $0x23, %r8
leal (%r8,%r8), %r9d
leal (%r9,%r9,4), %r9d
movl %ebp, %r10d
subl %r9d, %r10d
orb $0x30, %r10b
movb %r10b, (%rdx)
decq %rdx
cmpl $0x9, %ebp
movl %r8d, %ebp
ja 0x41ad
testl %ebx, %ebx
jns 0x41f5
sarq $0x20, %rcx
movb $0x2d, (%rax,%rcx)
jmp 0x41f5
xorl %eax, %eax
jmp 0x41f5
movb $0x30, (%rax)
movb $0x0, (%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_is_number.c
// Function: ft_is_number
int		ft_is_number(long long nb)
{
	int		i;

	i = 0;
	if (nb == 0)
		return (1);
	else if (nb < 0)
	{
		i++;
		nb *= -1;
	}
	while (nb > 0)
	{
		nb /= 10;
		i++;
	}
	return (i);
}

// Assembly:
testq %rdi, %rdi
je 0x4230
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
shrq $0x3f, %rdi
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
incl %edi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x4219
jmp 0x4235
movl $0x1, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_itoa_base.c
// Function: ft_itoa_base
char			*ft_itoa_base(int value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (res = ft_itoa(value));
	value = (value < 0) ? (unsigned int)value : (unsigned int)value;
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'a' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
cmpl $0xa, %esi
jne 0x4257
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4124
movl %esi, %ebx
testl %ebp, %ebp
je 0x4270
jle 0x4278
xorl %r15d, %r15d
movl %ebp, %eax
incl %r15d
cltd
idivl %ebx
testl %eax, %eax
jg 0x4264
jmp 0x427b
movl $0x1, %r15d
jmp 0x427b
xorl %r15d, %r15d
movslq %r15d, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x42bc
movl %r15d, %esi
incq %rsi
movl %ebp, %eax
cltd
idivl %ebx
leal 0x30(%rdx), %edi
leal 0x57(%rdx), %r8d
cmpl $0xa, %edx
cmovll %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movl %eax, %ebp
cmpq $0x1, %rsi
ja 0x4299
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_itoa_base_maj.c
// Function: ft_itoa_base_maj
char			*ft_itoa_base_maj(int value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_itoa(value));
	value = (value < 0) ? (unsigned int)value : (unsigned int)value;
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'A' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
cmpl $0xa, %esi
jne 0x42eb
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4124
movl %esi, %ebx
testl %ebp, %ebp
je 0x4304
jle 0x430c
xorl %r15d, %r15d
movl %ebp, %eax
incl %r15d
cltd
idivl %ebx
testl %eax, %eax
jg 0x42f8
jmp 0x430f
movl $0x1, %r15d
jmp 0x430f
xorl %r15d, %r15d
movslq %r15d, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x4350
movl %r15d, %esi
incq %rsi
movl %ebp, %eax
cltd
idivl %ebx
leal 0x30(%rdx), %edi
leal 0x37(%rdx), %r8d
cmpl $0xa, %edx
cmovll %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movl %eax, %ebp
cmpq $0x1, %rsi
ja 0x432d
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_ltoa_base.c
// Function: ft_ltoa_base
char			*ft_ltoa_base(long value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_ltoa(value));
	value = (value < 0) ? (unsigned long long)value : (unsigned long long)value;
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'a' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x4381
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a6c
movslq %esi, %r15
testq %rbx, %rbx
je 0x439e
jle 0x43a5
xorl %ebp, %ebp
movq %rbx, %rax
incl %ebp
cqto
idivq %r15
testq %rax, %rax
jg 0x4390
jmp 0x43a7
movl $0x1, %ebp
jmp 0x43a7
xorl %ebp, %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x43ec
movl %ebp, %esi
incq %rsi
movq %rbx, %rax
cqto
idivq %r15
leal 0x30(%rdx), %edi
leal 0x57(%rdx), %r8d
cmpq $0xa, %rdx
cmovll %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movq %rax, %rbx
cmpq $0x1, %rsi
ja 0x43c4
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_ltoa_base_maj.c
// Function: ft_ltoa_base_maj
char			*ft_ltoa_base_maj(long value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_ltoa(value));
	value = (value < 0) ? (unsigned long)value : (unsigned long)value;
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'A' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x441d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a6c
movslq %esi, %r15
testq %rbx, %rbx
je 0x443a
jle 0x4441
xorl %ebp, %ebp
movq %rbx, %rax
incl %ebp
cqto
idivq %r15
testq %rax, %rax
jg 0x442c
jmp 0x4443
movl $0x1, %ebp
jmp 0x4443
xorl %ebp, %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x4488
movl %ebp, %esi
incq %rsi
movq %rbx, %rax
cqto
idivq %r15
leal 0x30(%rdx), %edi
leal 0x37(%rdx), %r8d
cmpq $0xa, %rdx
cmovll %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movq %rax, %rbx
cmpq $0x1, %rsi
ja 0x4460
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_lltoa_base.c
// Function: ft_lltoa_base
char			*ft_lltoa_base(unsigned long long value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (res = ft_lltoa(value));
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'a' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x44b2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4b64
movslq %esi, %r15
testq %rbx, %rbx
je 0x44d3
xorl %esi, %esi
movq %rbx, %rcx
incl %esi
movq %rcx, %rax
xorl %edx, %edx
divq %r15
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x44bf
jmp 0x44d8
movl $0x1, %esi
movslq %esi, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
movl %r14d, %eax
incl %r14d
leaq (%rax,%rcx), %rsi
decq %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %edi
leal 0x57(%rdx), %r8d
cmpq $0xa, %rdx
cmovbl %edi, %r8d
movb %r8b, (%rsi)
decl %r14d
decq %rsi
movq %rax, %rbx
cmpl $0x1, %r14d
jg 0x44f8
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_lltoa_base_maj.c
// Function: ft_lltoa_base_maj
char			*ft_lltoa_base_maj(unsigned long long value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_lltoa(value));
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'A' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x4546
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4b64
movslq %esi, %r15
testq %rbx, %rbx
je 0x4567
xorl %esi, %esi
movq %rbx, %rcx
incl %esi
movq %rcx, %rax
xorl %edx, %edx
divq %r15
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x4553
jmp 0x456c
movl $0x1, %esi
movslq %esi, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
movl %r14d, %eax
incl %r14d
leaq (%rax,%rcx), %rsi
decq %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %edi
leal 0x37(%rdx), %r8d
cmpq $0xa, %rdx
cmovbl %edi, %r8d
movb %r8b, (%rsi)
decl %r14d
decq %rsi
movq %rax, %rbx
cmpl $0x1, %r14d
jg 0x458c
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_i_maxtoa_base.c
// Function: ft_i_maxtoa_base
char			*ft_i_maxtoa_base(intmax_t value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_i_maxtoa(value));
	value = (value < 0) ? (uintmax_t)value : (uintmax_t)value;
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'a' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x45e1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c10
movslq %esi, %r15
testq %rbx, %rbx
je 0x45fe
jle 0x4605
xorl %ebp, %ebp
movq %rbx, %rax
incl %ebp
cqto
idivq %r15
testq %rax, %rax
jg 0x45f0
jmp 0x4607
movl $0x1, %ebp
jmp 0x4607
xorl %ebp, %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x464c
movl %ebp, %esi
incq %rsi
movq %rbx, %rax
cqto
idivq %r15
leal 0x30(%rdx), %edi
leal 0x57(%rdx), %r8d
cmpq $0xa, %rdx
cmovll %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movq %rax, %rbx
cmpq $0x1, %rsi
ja 0x4624
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_ui_maxtoa_base.c
// Function: ft_ui_maxtoa_base
char			*ft_ui_maxtoa_base(uintmax_t value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_lltoa(value));
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'a' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x467f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4b64
movslq %esi, %r15
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x46a0
movq %rbx, %rcx
incl %r12d
movq %rcx, %rax
xorl %edx, %edx
divq %r15
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x468d
movslq %r12d, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x46e6
movl %r12d, %esi
incq %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %edi
leal 0x57(%rdx), %r8d
cmpq $0xa, %rdx
cmovbl %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movq %rax, %rbx
cmpq $0x1, %rsi
ja 0x46be
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_ui_maxtoa_base_maj.c
// Function: ft_ui_maxtoa_base_maj
char			*ft_ui_maxtoa_base_maj(uintmax_t value, int base)
{
	char		*res;
	int			i;

	res = NULL;
	if (base == 10)
		return (ft_ui_maxtoa(value));
	i = ft_count(value, base);
	res = (char*)malloc(sizeof(char) * i);
	res[i] = 0;
	while (i-- > 0)
	{
		res[i] = value % base + ((value % base > 9) ? 'A' - 10 : '0');
		value /= base;
	}
	return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xa, %esi
jne 0x471b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4d08
movslq %esi, %r15
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x473c
movq %rbx, %rcx
incl %r12d
movq %rcx, %rax
xorl %edx, %edx
divq %r15
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x4729
movslq %r12d, %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testl %r14d, %r14d
jle 0x4782
movl %r12d, %esi
incq %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %edi
leal 0x37(%rdx), %r8d
cmpq $0xa, %rdx
cmovbl %edi, %r8d
movb %r8b, -0x2(%rcx,%rsi)
decq %rsi
movq %rax, %rbx
cmpq $0x1, %rsi
ja 0x475a
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_stock_flags.c
// Function: ft_verif_conv
int				ft_verif_conv(t_var *var, char c)
{
	if (c != 'l' && c != 'h' && c != 'z' && c != 'j' && c != '-' &&
		c != '+' && c != '0' && c != ' ' && c != '#' && c != '.' && c != '%'
		&& !ft_strchr(var->flags_conv, c))
	{
		if (!ft_isdigit(c))
		{
			var->nb.c = c;
			var->res = &c;
			return (1);
		}
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x30, %esi
ja 0x47bb
movl %r15d, %eax
movabsq $0x1682900000000, %rcx  # imm = 0x1682900000000
btq %rax, %rcx
jb 0x47ce
leal -0x68(%r15), %eax
cmpl $0x12, %eax
ja 0x47db
movl $0x40015, %ecx          # imm = 0x40015
btl %eax, %ecx
jae 0x47db
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsbl %r15b, %ebp
leaq 0x4a(%r14), %rdi
movl %ebp, %esi
callq 0x3fe4
testq %rax, %rax
jne 0x47ce
movl %ebp, %edi
callq 0x4dc8
testl %eax, %eax
jne 0x47ce
movb %r15b, 0x70(%r14)
leaq 0x7(%rsp), %rax
movq %rax, (%r14)
movl $0x1, %ebx
jmp 0x47ce
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_stock_flags.c
// Function: ft_stock_flags3
int				ft_stock_flags3(char *str, t_var *var, int *i)
{
	if (ft_verif_conv(var, str[*i]))
	{
		ft_type(var, 'N');
		if (!str[*i + 1])
			return (*i);
		else
		{
			*i = *i + 1;
			return (*i);
		}
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq (%rdx), %rax
movsbl (%rdi,%rax), %esi
movq %r15, %rdi
callq 0x4794
testl %eax, %eax
je 0x484d
movq %r15, %rdi
movl $0x4e, %esi
callq 0x49dc
movslq (%rbx), %rax
cmpb $0x0, 0x1(%r14,%rax)
je 0x484f
incq %rax
movl %eax, (%rbx)
jmp 0x484f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_stock_flags.c
// Function: ft_stock_flags
int				ft_stock_flags(char *str, t_var *var)
{
	int			i;
	int			j;

	i = 0;
	j = 0;
	var->i_stock = 0;
	while (str[i])
	{
		if (ft_strchr(var->flags_conv, str[i]))
			ft_type(var, str[i]);
		while (var->flags_conv[j] && var->flags_conv[j] != str[i])
			j++;
		if (var->flags_conv[j] == str[i])
			return (i + 1);
		j = 0;
		if (ft_stock_flags3(str, var, &i))
			return (i);
		var->flags_stock[var->i_stock++] = str[i++];
		var->flags_stock[var->i_stock] = 0;
		if (ft_stock_flags2(str, var, &i))
			return (i);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0xc(%rsp), %rax
movl %r13d, (%rax)
movl %r13d, 0x68(%rsi)
leaq 0x4a(%rsi), %r12
movb (%rdi), %al
leaq 0x4b(%rsi), %rcx
movq %rcx, 0x10(%rsp)
xorl %r15d, %r15d
testb %al, %al
je 0x4962
movslq %r15d, %rbp
movsbl %al, %esi
movq %r12, %rdi
callq 0x3fe4
testq %rax, %rax
je 0x48b2
movsbl (%r14,%rbp), %esi
movq %rbx, %rdi
callq 0x49dc
movb (%r12), %dl
movb (%r14,%rbp), %al
movq 0x10(%rsp), %rcx
testb %dl, %dl
je 0x48d2
cmpb %al, %dl
je 0x495c
movb (%rcx), %dl
incq %rcx
jmp 0x48bf
testb %al, %al
je 0x495c
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x480d
movl 0xc(%rsp), %ebp
testl %eax, %eax
jne 0x4957
movslq %ebp, %rax
leaq 0x1(%rax), %r15
movl %r15d, 0xc(%rsp)
movb (%r14,%rax), %cl
movslq 0x68(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x68(%rbx)
movb %cl, 0x18(%rbx,%rdx)
movslq 0x68(%rbx), %rcx
movb $0x0, 0x18(%rbx,%rcx)
movzbl 0x1(%r14,%rax), %eax
cmpl $0x25, %eax
je 0x492c
testl %eax, %eax
jne 0x488a
movq %rbx, %rdi
movl $0x25, %esi
callq 0x49dc
movb (%r14,%r15), %al
movslq 0x68(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x68(%rbx)
movb %al, 0x18(%rbx,%rcx)
addl $0x2, %ebp
movslq 0x68(%rbx), %rax
movb $0x0, 0x18(%rbx,%rax)
movl %ebp, %r13d
jmp 0x4962
incl %r15d
movl %r15d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_type.c
// Function: ft_type2
void	ft_type2(t_var *var, char c)
{
	if (c == 'o')
		var->type = TYPE_OCTAL;
	else if (c == 'O')
		var->type = TYPE_OCTAL_MAJ;
	else if (c == 'u')
		var->type = TYPE_UNSIGNED;
	else if (c == 'U')
		var->type = TYPE_UNSIGNED_MAJ;
	else if (c == '%')
		var->type = TYPE_MODULO;
	else if (c == 'b')
		var->type = TYPE_BITWISE;
	else if (c == 'S')
		var->type = TYPE_WSTRING;
	else if (c == 'N')
		var->type = TYPE_NON_CONNU;
}

// Assembly:
cmpl $0x61, %esi
jg 0x4995
leal -0x4e(%rsi), %eax
cmpl $0x7, %eax
ja 0x49ab
leaq 0x85c(%rip), %rcx       # 0x51e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x49d8
cmpl $0x62, %esi
je 0x49cc
cmpl $0x6f, %esi
je 0x49d3
cmpl $0x75, %esi
jne 0x49db
movl $0x9, %eax
jmp 0x49d8
cmpl $0x25, %esi
jne 0x49db
movl $0x1, %eax
jmp 0x49d8
movl $0xa, %eax
jmp 0x49d8
movl $0xc, %eax
jmp 0x49d8
movl $0x5, %eax
jmp 0x49d8
movl $0x12, %eax
jmp 0x49d8
movl $0xb, %eax
movl %eax, 0x78(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_type.c
// Function: ft_type
void	ft_type(t_var *var, char c)
{
	if (c == 'c')
		var->type = TYPE_CHAR;
	else if (c == 'C')
		var->type = TYPE_WCHAR;
	else if (c == 'd')
		var->type = TYPE_SHORT;
	else if (c == 'D')
		var->type = TYPE_SHORT_MAJ;
	else if (c == 'i')
		var->type = TYPE_INT;
	else if (c == 's')
		var->type = TYPE_STRING;
	else if (c == 'x')
		var->type = TYPE_HEXA;
	else if (c == 'X')
		var->type = TYPE_HEXA_MAJ;
	else if (c == 'p')
		var->type = TYPE_ADDRESS;
	else
		ft_type2(var, c);
}

// Assembly:
cmpl $0x63, %esi
jle 0x49fd
cmpl $0x6f, %esi
jle 0x4a26
cmpl $0x70, %esi
je 0x4a48
cmpl $0x73, %esi
je 0x4a58
cmpl $0x78, %esi
jne 0x4a60
movl $0xd, 0x78(%rdi)
retq
cmpl $0x57, %esi
jg 0x4a14
cmpl $0x43, %esi
je 0x4a38
cmpl $0x44, %esi
jne 0x4a60
movl $0x8, 0x78(%rdi)
retq
cmpl $0x58, %esi
je 0x4a40
cmpl $0x63, %esi
jne 0x4a60
movl $0x2, 0x78(%rdi)
retq
cmpl $0x64, %esi
je 0x4a50
cmpl $0x69, %esi
jne 0x4a60
movl $0x7, 0x78(%rdi)
retq
movl $0x3, 0x78(%rdi)
retq
movl $0xe, 0x78(%rdi)
retq
movl $0xf, 0x78(%rdi)
retq
movl $0x6, 0x78(%rdi)
retq
movl $0x4, 0x78(%rdi)
retq
movsbl %sil, %esi
jmp 0x4974
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_ltoa.c
// Function: ft_ltoa
char		*ft_ltoa(long int n)
{
	int				i;
	long			cpy;
	int				flg;
	char			*str;

	if (n < -9223372036854775807)
		return (str = ft_lol());
	i = 0;
	flg = ABS(n);
	n = (flg == 0) ? n : n * -1;
	cpy = n;
	i = ft_count(cpy);
	(flg == 1) ? i++ : i;
	if ((str = (char *)malloc(sizeof(*str) * i + 1 + flg)) == 0)
		return (0);
	if (n == 0)
		str[0] = '0';
	str[i--] = '\0';
	str = ft_print(str, n, &i);
	if (flg == 1)
		str[i] = '-';
	return (str);
}

// Assembly:
movq %rdi, %rax
negq %rax
jno 0x4a80
leaq 0x789(%rip), %rdi       # 0x5204
jmp 0x3f08
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rsi
shrq $0x3f, %rsi
movq %rdi, %r14
negq %r14
cmovsq %rdi, %r14
movl $0x1, %edi
cmpq $0xa, %r14
jb 0x4acb
movl $0x1, %edi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %r14, %rcx
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
incl %edi
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x4ab6
leal (%rsi,%rdi), %eax
movslq %eax, %r15
leaq (%rsi,%r15), %rdi
incq %rdi
callq 0x10b0
testq %rax, %rax
je 0x4b4f
movq %rax, %rcx
testq %rbx, %rbx
je 0x4b53
leal -0x1(%r15), %eax
movb $0x0, (%rcx,%r15)
movslq %eax, %rsi
movq %rcx, %rdi
addq %rsi, %rdi
shlq $0x20, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $-0x100000000, %r9      # imm = 0xFFFFFFFF00000000
movq %r14, %rax
mulq %r8
addq %r9, %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, (%rdi)
decq %rdi
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x4b14
testq %rbx, %rbx
jns 0x4b5b
sarq $0x20, %rsi
movb $0x2d, (%rcx,%rsi)
jmp 0x4b5b
xorl %ecx, %ecx
jmp 0x4b5b
movb $0x30, (%rcx)
movb $0x0, (%rcx,%r15)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_lltoa.c
// Function: ft_lltoa
char		*ft_lltoa(unsigned long long n)
{
	int				i;
	long long		cpy;
	int				flg;
	char			*str;

	i = 0;
	flg = ABS(n);
	n = (flg == 0) ? n : n * -1;
	cpy = n;
	i = ft_count(cpy);
	(flg == 1) ? i++ : i;
	if ((str = (char *)malloc(sizeof(*str) * i + 1 + flg)) == 0)
		return (0);
	if (n == 0)
		str[0] = '0';
	str[i--] = '\0';
	str = ft_print(str, n, &i);
	if (flg == 1)
		str[i] = '-';
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
cmpq $0xa, %rdi
jb 0x4b9a
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rcx
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
incq %r14
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x4b84
leaq 0x1(%r14), %rdi
callq 0x10b0
movq %rax, %rcx
testq %rax, %rax
je 0x4bf9
testq %rbx, %rbx
je 0x4bf1
movb $0x0, (%rcx,%r14)
leaq (%rcx,%r14), %rsi
decq %rsi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ebx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, (%rsi)
decq %rsi
cmpq $0x9, %rbx
movq %rdx, %rbx
ja 0x4bc6
jmp 0x4bf9
movb $0x30, (%rcx)
movb $0x0, (%rcx,%r14)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_i_maxtoa.c
// Function: ft_i_maxtoa
char		*ft_i_maxtoa(intmax_t n)
{
	int				i;
	intmax_t		cpy;
	int				flg;
	char			*str;

	if (n < -9223372036854775807)
	{
		return (str = ft_lol());
	}
	i = 0;
	flg = ABS(n);
	n = (flg == 0) ? n : n * -1;
	cpy = n;
	i = ft_count(cpy);
	(flg == 1) ? i++ : i;
	if ((str = (char *)malloc(sizeof(*str) * i + 1 + flg)) == 0)
		return (0);
	if (n == 0)
		str[0] = '0';
	str[i--] = '\0';
	str = ft_print(str, n, &i);
	if (flg == 1)
		str[i] = '-';
	return (str);
}

// Assembly:
movq %rdi, %rax
negq %rax
jno 0x4c24
leaq 0x5e5(%rip), %rdi       # 0x5204
jmp 0x3f08
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rsi
shrq $0x3f, %rsi
movq %rdi, %r14
negq %r14
cmovsq %rdi, %r14
movl $0x1, %edi
cmpq $0xa, %r14
jb 0x4c6f
movl $0x1, %edi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %r14, %rcx
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
incl %edi
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x4c5a
leal (%rsi,%rdi), %eax
movslq %eax, %r15
leaq (%rsi,%r15), %rdi
incq %rdi
callq 0x10b0
testq %rax, %rax
je 0x4cf3
movq %rax, %rcx
testq %rbx, %rbx
je 0x4cf7
leal -0x1(%r15), %eax
movb $0x0, (%rcx,%r15)
movslq %eax, %rsi
movq %rcx, %rdi
addq %rsi, %rdi
shlq $0x20, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $-0x100000000, %r9      # imm = 0xFFFFFFFF00000000
movq %r14, %rax
mulq %r8
addq %r9, %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, (%rdi)
decq %rdi
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x4cb8
testq %rbx, %rbx
jns 0x4cff
sarq $0x20, %rsi
movb $0x2d, (%rcx,%rsi)
jmp 0x4cff
xorl %ecx, %ecx
jmp 0x4cff
movb $0x30, (%rcx)
movb $0x0, (%rcx,%r15)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/tst/scan.c
// Function: test_parseConstant
void test_parseConstant() {
    //const char *dec32 = "32";
    const char *hex32 = "0x32";
    op_t op = parseConstant(&hex32);
    assert(op == PUSH1);
    op = scanNextOp(&hex32);
    assert(op == 0x32);
}

// Assembly:
pushq %rax
leaq 0x2ca7(%rip), %rax      # 0x603b
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x38a6
cmpb $0x60, %al
jne 0x33b1
movq %rsp, %rdi
callq 0x3a9b
cmpb $0x32, %al
jne 0x33d0
popq %rax
retq
leaq 0x2c4c(%rip), %rdi      # 0x6004
leaq 0x2c51(%rip), %rsi      # 0x6010
leaq 0x2c55(%rip), %rcx      # 0x601b
movl $0xa, %edx
callq 0x3050
leaq 0x2c5e(%rip), %rdi      # 0x6035
leaq 0x2c32(%rip), %rsi      # 0x6010
leaq 0x2c36(%rip), %rcx      # 0x601b
movl $0xc, %edx
callq 0x3050
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/randhhh2D.c
// Function: init
void init(double SSepsilon, double prob) {
	int i;
	SSepsval = SSepsilon;
	srand(SEED);
#ifdef PROB
	ignoreProb = 1 - prob;
	logIgnoreProb = log(ignoreProb);
	minusQuantity = log(RAND_MAX) / logIgnoreProb;
	nrIgnore = log((float)rand()) / logIgnoreProb - minusQuantity;
#endif
	for (i = 0; i < NUM_COUNTERS; i++)
		counters[i] = LCU_Init(SSepsval);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, 0x3ea7(%rip)     # 0x51f0
movl $0xd5d, %edi            # imm = 0xD5D
callq 0x10f0
xorl %ebx, %ebx
leaq 0x3ea4(%rip), %r14      # 0x5200
xorps %xmm0, %xmm0
cvtsd2ss 0x3e89(%rip), %xmm0     # 0x51f0
callq 0x186c
movq %rax, (%rbx,%r14)
addq $0x8, %rbx
cmpq $0xc8, %rbx
jne 0x135c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/bench/random_mixed/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct sock_addr ** sas;
	uintmax_t N;
	int s;
	struct wire_requestqueue * Q;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 3) {
		fprintf(stderr, "usage: random_mixed %s N\n", "<socketname>");
		exit(1);
	}

	/* Parse N. */
	if (PARSENUM(&N, argv[2])) {
		warnp("Invalid value for N: %s", argv[2]);
		exit(1);
	}

	/* Resolve the socket address and connect. */
	if ((sas = sock_resolve(argv[1])) == NULL) {
		warnp("Error resolving socket address: %s", argv[1]);
		exit(1);
	}
	if (sas[0] == NULL) {
		warn0("No addresses found for %s", argv[1]);
		exit(1);
	}
	if ((s = sock_connect(sas)) == -1)
		exit(1);

	/* Create a request queue. */
	if ((Q = wire_requestqueue_init(s)) == NULL) {
		warnp("Cannot create packet write queue");
		exit(1);
	}

	/* Start issuing random mixed requests. */
	if (randommixed(Q, N))
		exit(1);

	/* Free the request queue. */
	wire_requestqueue_destroy(Q);
	wire_requestqueue_free(Q);

	/* Free socket addresses. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x258b
callq 0x5048
cmpl $0x3, %ebx
jne 0x25c3
callq 0x2090
movl $0x0, (%rax)
movq 0x10(%r14), %r12
testq %r12, %r12
jne 0x25e4
leaq 0xaaf6(%rip), %rdi      # 0xd0a1
leaq 0xaaf9(%rip), %rsi      # 0xd0ab
leaq 0xab14(%rip), %rcx      # 0xd0cd
movl $0xbb, %edx
callq 0x2160
movq 0x10a2e(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
leaq 0xaa30(%rip), %rsi      # 0xd004
leaq 0xaa43(%rip), %rdx      # 0xd01e
xorl %eax, %eax
callq 0x21d0
jmp 0x2654
movq %rax, %rbx
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x22a0
movq %rax, %r15
movq (%r13), %rax
cmpq %r12, %rax
je 0x2636
cmpb $0x0, (%rax)
jne 0x2636
cmpl $0x0, (%rbx)
jne 0x263c
movq 0x8(%r14), %rdi
callq 0x4044
testq %rax, %rax
jne 0x265e
cmpl $0x0, (%rbx)
movq 0x8(%r14), %rsi
leaq 0xaa18(%rip), %rdi      # 0xd043
jne 0x2647
xorl %eax, %eax
callq 0x51e7
jmp 0x2654
movl $0x16, (%rbx)
movq 0x10(%r14), %rsi
leaq 0xa9e4(%rip), %rdi      # 0xd02b
xorl %eax, %eax
callq 0x50c8
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x22d0
movq %rax, %r12
cmpq $0x0, (%rax)
jne 0x267b
movq 0x8(%r14), %rsi
leaq 0xa9f4(%rip), %rdi      # 0xd066
xorl %eax, %eax
callq 0x51e7
jmp 0x264e
movq %r12, %rdi
callq 0x495c
cmpl $-0x1, %eax
je 0x2654
movl %eax, %edi
callq 0x6e68
testq %rax, %rax
jne 0x26a9
cmpl $0x0, (%rbx)
jne 0x26da
leaq 0xa9e0(%rip), %rdi      # 0xd080
xorl %eax, %eax
callq 0x51e7
jmp 0x2654
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x26ed
testl %eax, %eax
jne 0x2654
movq %r14, %rdi
callq 0x7559
movq %r14, %rdi
callq 0x756d
movq %r12, %rdi
callq 0x4756
xorl %edi, %edi
callq 0x22d0
leaq 0xa99f(%rip), %rdi      # 0xd080
xorl %eax, %eax
callq 0x50c8
jmp 0x264e