LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_largeur.c
// Function: ft_flags_precision
void			ft_flags_precision(t_var *var, t_flags *s_flags, int i)
{
	ft_bzero(var->buf_tmp, 500);
	if (!s_flags->precision && ft_strchr(var->flags_stock, '.') &&
		var->type > TYPE_MODULO)
		var->res = 0;
	if (!s_flags->precision && var->res)
		s_flags->precision = (int)ft_strlen(var->res);
	var->i_buf_tmp = (s_flags->c & (1 << 2)) ?
		0 : s_flags->largeur - s_flags->precision;
	if (var->res)
		(var->i_buf_tmp < 0) ? ft_memcpy(&var->buf_tmp[0], var->res,
s_flags->precision) : ft_memcpy(&var->buf_tmp[var->i_buf_tmp],
var->res, s_flags->precision);
	if (!var->i_buf_tmp)
	{
		i = s_flags->precision;
		var->i_buf_tmp = s_flags->largeur;
	}
	while (i < var->i_buf_tmp)
	{
		if ((!(s_flags->c & (1 << 2))) && (s_flags->c & (1 << 0)))
			var->buf_tmp[i++] = '0';
		else
			var->buf_tmp[i++] = ' ';
	}
	ft_flags_precision2(var, 0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x3f38
movl 0x8(%r14), %eax
testl %eax, %eax
jne 0x30de
leaq 0x18(%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x3e3c
testq %rax, %rax
je 0x30c1
cmpl $0x2, 0x78(%rbx)
jl 0x30c1
andq $0x0, (%rbx)
movl 0x8(%r14), %eax
testl %eax, %eax
jne 0x30de
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30dc
callq 0x3d20
movl %eax, 0x8(%r14)
jmp 0x30de
xorl %eax, %eax
xorl %ecx, %ecx
testb $0x4, (%r14)
jne 0x30ec
movl 0x4(%r14), %ecx
subl %eax, %ecx
movl %ecx, 0x64(%rbx)
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x310d
xorl %edi, %edi
testl %ecx, %ecx
cmovgl %ecx, %edi
addq 0x10(%rbx), %rdi
movslq %eax, %rdx
callq 0x3f4c
movl 0x64(%rbx), %ecx
testl %ecx, %ecx
jne 0x311c
movl 0x4(%r14), %ecx
movl 0x8(%r14), %ebp
movl %ecx, 0x64(%rbx)
movslq %ebp, %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3148
movb (%r14), %cl
andb $0x5, %cl
cmpb $0x1, %cl
sete %cl
movq 0x10(%rbx), %rdx
shlb $0x4, %cl
orb $0x20, %cl
movb %cl, (%rdx,%rax)
incq %rax
movl 0x64(%rbx), %ecx
jmp 0x311f
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x3d20
cltq
cmpq %rax, %r14
jge 0x3179
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movb (%rcx,%r14), %cl
incq %r14
movslq 0x60(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x60(%rbx)
movb %cl, (%rax,%rdx)
jmp 0x314b
cmpl $0x2, 0x78(%rbx)
jne 0x31d2
cmpb $0x0, 0x70(%rbx)
jne 0x31d2
movq 0x10(%rbx), %rdi
callq 0x3d20
testq %rax, %rax
je 0x31a4
movb 0x70(%rbx), %al
movq 0x8(%rbx), %rcx
movslq 0x60(%rbx), %rdx
movb %al, -0x1(%rcx,%rdx)
jmp 0x31d2
cmpl $0x2, 0x78(%rbx)
jne 0x31d2
cmpb $0x0, 0x70(%rbx)
jne 0x31d2
movq 0x10(%rbx), %rdi
callq 0x3d20
testq %rax, %rax
jne 0x31d2
movb 0x70(%rbx), %al
movq 0x8(%rbx), %rcx
movslq 0x60(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x60(%rbx)
movb %al, (%rcx,%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_largeur.c
// Function: ft_flags_largeur
void			ft_flags_largeur(t_var *var, t_flags *s_flags, int i)
{
	int			len;

	len = (int)ft_strlen(var->res);
	if (s_flags->largeur < len)
		var->i_buf_tmp = 0;
	else if (s_flags->precision >= len)
		var->i_buf_tmp = (s_flags->c & (1 << 2)) ? 0 :
			s_flags->largeur - len;
	else
		var->i_buf_tmp = (s_flags->c & (1 << 2)) ? 0 : s_flags->largeur;
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], var->res, len + 1);
	if (var->type == TYPE_NON_CONNU)
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], var->res, len);
	if (!var->i_buf_tmp)
	{
		i = len;
		var->i_buf_tmp = s_flags->largeur;
	}
	if (s_flags->precision < (int)ft_strlen(var->res))
		var->i_buf_tmp += len;
	ft_flags_largeur2(var, s_flags, i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3d20
movq %rax, %r15
movl %r15d, %r12d
movl 0x4(%r14), %ecx
xorl %eax, %eax
movl %ecx, %edx
subl %r15d, %edx
jl 0x321f
movb (%r14), %sil
cmpl %r12d, 0x8(%r14)
jge 0x3216
xorl %eax, %eax
testb $0x4, %sil
cmovel %ecx, %eax
jmp 0x321f
xorl %eax, %eax
testb $0x4, %sil
cmovel %edx, %eax
movl %eax, 0x64(%rbx)
movslq %eax, %rdi
addq 0x10(%rbx), %rdi
movq (%rbx), %rsi
shlq $0x20, %r15
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %r15, %rdx
sarq $0x20, %rdx
callq 0x3f4c
cmpl $0x0, 0x78(%rbx)
jne 0x3263
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq (%rbx), %rsi
sarq $0x20, %r15
movq %r15, %rdx
callq 0x3f4c
cmpl $0x0, 0x64(%rbx)
jne 0x3273
movl 0x4(%r14), %eax
movl %eax, 0x64(%rbx)
movl %r12d, %ebp
movl 0x8(%r14), %r15d
movq (%rbx), %rdi
callq 0x3d20
cmpl %eax, %r15d
jge 0x3288
addl %r12d, 0x64(%rbx)
movslq %ebp, %rax
movslq 0x64(%rbx), %rcx
cmpq %rcx, %rax
jge 0x32b2
movb (%r14), %cl
andb $0x5, %cl
cmpb $0x1, %cl
sete %cl
movq 0x10(%rbx), %rdx
shlb $0x4, %cl
orb $0x20, %cl
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x328b
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x3d20
cltq
cmpq %rax, %r14
jge 0x32e3
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movb (%rcx,%r14), %cl
incq %r14
movslq 0x60(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x60(%rbx)
movb %cl, (%rax,%rdx)
jmp 0x32b5
cmpl $0x2, 0x78(%rbx)
jne 0x333c
cmpb $0x0, 0x70(%rbx)
jne 0x333c
movq 0x10(%rbx), %rdi
callq 0x3d20
testq %rax, %rax
je 0x330e
movb 0x70(%rbx), %al
movq 0x8(%rbx), %rcx
movslq 0x60(%rbx), %rdx
movb %al, -0x1(%rcx,%rdx)
jmp 0x333c
cmpl $0x2, 0x78(%rbx)
jne 0x333c
cmpb $0x0, 0x70(%rbx)
jne 0x333c
movq 0x10(%rbx), %rdi
callq 0x3d20
testq %rax, %rax
jne 0x333c
movb 0x70(%rbx), %al
movq 0x8(%rbx), %rcx
movslq 0x60(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x60(%rbx)
movb %al, (%rcx,%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_stock_buf_base.c
// Function: ft_stock_buf_base3
void		ft_stock_buf_base3(t_var *var, t_flags *s_flags)
{
	int		i;
	int		x;
	int		x2;

	x = (var->type >= TYPE_OCTAL && var->type <= TYPE_OCTAL_MAJ);
	x2 = s_flags->largeur - s_flags->precision;
	i = s_flags->largeur - s_flags->precision;
	if (var->i_plus && !(s_flags->c &= (1 << 0)))
		var->buf[var->i_buf++] = '+';
	if (((!ft_strchr(var->flags_stock, '.') && !s_flags->precision && !x) ||
	(x && s_flags->c < 16) || (ft_strchr(var->flags_stock, '.') &&
				s_flags->precision && x2 > var->len_str_hexa)))
	{
		if (!ft_strchr(var->flags_stock, '.'))
			var->buf[var->i_buf++] = '0';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x78(%rdi), %r12d
movl 0x4(%rsi), %ebp
subl 0x8(%rsi), %ebp
cmpl $0x0, 0x7c(%rdi)
je 0x3382
movb (%r14), %al
andb $0x1, %al
movb %al, (%r14)
jne 0x3382
movq 0x8(%rbx), %rax
movslq 0x60(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x60(%rbx)
movb $0x2b, (%rax,%rcx)
addl $-0xb, %r12d
leaq 0x18(%rbx), %r15
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x3e3c
testq %rax, %rax
je 0x33c7
cmpl $0x1, %r12d
ja 0x33a6
cmpb $0x10, (%r14)
jl 0x33d4
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x3e3c
testq %rax, %rax
je 0x33f6
cmpl $0x0, 0x8(%r14)
je 0x33f6
cmpl 0x88(%rbx), %ebp
jg 0x33d4
jmp 0x33f6
cmpl $0x2, %r12d
jb 0x339a
cmpl $0x0, 0x8(%r14)
jne 0x339a
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x3e3c
testq %rax, %rax
jne 0x33f6
movq 0x8(%rbx), %rax
movslq 0x60(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x60(%rbx)
movb $0x30, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_stock_buf_base.c
// Function: ft_stock_buf_base
int			ft_stock_buf_base(t_var *var, t_flags *s_flags, int res_strcmp)
{
	int		i;

	i = 0;
	if (!res_strcmp && s_flags->m == 0 && s_flags->c >= 2 &&
	s_flags->c <= 16 && (!var->i_buf || (var->type >= TYPE_OCTAL &&
						var->type <= TYPE_OCTAL_MAJ)))
		ft_stock_buf_base3(var, s_flags);
	else if (((s_flags->c & (1 << 4)) && (var->type >= TYPE_HEXA &&
	var->type <= TYPE_HEXA_MAJ) && res_strcmp) || var->type == TYPE_ADDRESS)
	{
		i = 2;
		if ((var->type == TYPE_HEXA) || var->type == TYPE_ADDRESS)
			ft_memcpy(&var->buf_tmp[var->i_buf_tmp], "0x", var->i_buf_tmp += i);
		else if (var->type == TYPE_HEXA_MAJ)
		{
			ft_memcpy(&var->buf_tmp[var->i_buf_tmp], "0X", i);
			var->i_buf_tmp += i;
		}
	}
	else
		i = ft_stock_buf_base2(var, s_flags, res_strcmp);
	return (i);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x340d
movb (%rsi), %al
jmp 0x344d
cmpb $0x0, 0xc(%rsi)
sete %cl
movb (%rsi), %al
movl %eax, %edi
addb $-0x2, %dil
cmpb $0xf, %dil
setb %dil
andb %cl, %dil
cmpb $0x1, %dil
jne 0x344d
cmpl $0x0, 0x60(%rbx)
je 0x343e
movl 0x78(%rbx), %ecx
addl $-0xb, %ecx
cmpl $0x1, %ecx
ja 0x344d
movq %rbx, %rdi
callq 0x3348
xorl %ebp, %ebp
jmp 0x34e4
movl 0x78(%rbx), %ecx
testb $0x10, %al
je 0x348d
testl %edx, %edx
setne %dil
leal -0xd(%rcx), %r8d
cmpl $0x2, %r8d
setb %r8b
testb %r8b, %dil
je 0x348d
cmpl $0xd, %ecx
je 0x3492
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x1d53(%rip), %rsi      # 0x51d2
pushq $0x2
popq %rdx
callq 0x3f4c
addl $0x2, 0x64(%rbx)
jmp 0x34b0
cmpl $0xf, %ecx
jne 0x34b5
movslq 0x64(%rbx), %rdx
movq 0x10(%rbx), %rdi
addq %rdx, %rdi
addq $0x2, %rdx
movl %edx, 0x64(%rbx)
leaq 0x1ce0(%rip), %rsi      # 0x518b
callq 0x3f4c
pushq $0x2
popq %rbp
jmp 0x34e4
addl $-0xb, %ecx
cmpl $0x2, %ecx
setae %cl
testb $0x10, %al
sete %al
xorl %ebp, %ebp
orb %cl, %al
jne 0x34e4
testl %edx, %edx
je 0x34d3
cmpl $0x0, 0x8(%rsi)
je 0x34ed
leaq 0x18(%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x3e3c
testq %rax, %rax
je 0x34fe
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x18(%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x3e3c
testq %rax, %rax
je 0x34d3
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x1cc3(%rip), %rsi      # 0x51d0
pushq $0x1
popq %rdx
callq 0x3f4c
incl 0x64(%rbx)
pushq $0x1
jmp 0x34b2
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock2.c
// Function: ft_flags_stock2_5
void	ft_flags_stock2_5(t_var *var, t_flags *s_flags, char *str_hexa)
{
	ft_split2_5(s_flags, var);
	(var->k < 0) ? var->k = 0 : 0;
	if (s_flags->largeur > var->len_str_hexa)
		ft_memset(&var->buf_tmp[var->i_buf_tmp], ' ', var->i_buf_tmp += var->k);
	(var->type == TYPE_ADDRESS) ?
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], "0x", var->i_buf_tmp += 2) : 0;
	if (!(!var->res_strcmp && s_flags->m == 0))
	{
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], str_hexa,
		var->i_buf_tmp += var->len_str_hexa);
	}
	else if (!var->res_strcmp && s_flags->m == 0 && var->type >= TYPE_OCTAL
	&& var->type <= TYPE_OCTAL_MAJ && !ft_strchr(var->flags_stock, '.'))
	{
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], str_hexa,
		var->i_buf_tmp += var->len_str_hexa);
	}
	else if (var->type == TYPE_ADDRESS && !var->res_strcmp)
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], str_hexa,
		var->i_buf_tmp += var->len_str_hexa);
	(var->type == TYPE_ADDRESS) ?
	ft_memcpy(&var->buf[var->i_buf], var->buf_tmp, var->i_buf_tmp) :
	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;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x3c0c
movl 0x90(%rbx), %eax
testl %eax, %eax
jns 0x3570
andl $0x0, 0x90(%rbx)
xorl %eax, %eax
movl 0x4(%r15), %ecx
cmpl 0x88(%rbx), %ecx
jle 0x3598
movslq 0x64(%rbx), %rcx
movq 0x10(%rbx), %rdi
addq %rcx, %rdi
movslq %eax, %rdx
addq %rcx, %rdx
movl %edx, 0x64(%rbx)
pushq $0x20
popq %rsi
callq 0x3f24
cmpl $0xf, 0x78(%rbx)
jne 0x35bc
movslq 0x64(%rbx), %rdx
movq 0x10(%rbx), %rdi
addq %rdx, %rdi
addq $0x2, %rdx
movl %edx, 0x64(%rbx)
leaq 0x1bd4(%rip), %rsi      # 0x518b
callq 0x3f4c
cmpl $0x0, 0x8c(%rbx)
jne 0x35cc
cmpb $0x0, 0xc(%r15)
je 0x361e
movslq 0x64(%rbx), %rax
movq 0x10(%rbx), %rdi
addq %rax, %rdi
movslq 0x88(%rbx), %rdx
addq %rax, %rdx
movl %edx, 0x64(%rbx)
movq %r14, %rsi
callq 0x3f4c
cmpl $0xf, 0x78(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movslq 0x60(%rbx), %rax
movl 0x64(%rbx), %ecx
je 0x3607
addl 0x88(%rbx), %ecx
addq %rax, %rdi
movslq %ecx, %rdx
callq 0x3f4c
movl 0x64(%rbx), %eax
addl %eax, 0x60(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl 0x78(%rbx), %eax
leal -0xb(%rax), %ecx
cmpl $0x1, %ecx
ja 0x363d
leaq 0x18(%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x3e3c
testq %rax, %rax
je 0x35cc
movl 0x78(%rbx), %eax
cmpl $0xf, %eax
jne 0x35ec
cmpl $0x0, 0x8c(%rbx)
jne 0x35ec
jmp 0x35cc
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock2.c
// Function: ft_flags_stock2_4
void	ft_flags_stock2_4(t_var *var, t_flags *s_flags, char *str_hexa, int i)
{
	var->i_moins = ft_stock_moins(var, str_hexa);
	var->i_plus = ft_stock_plus(var, s_flags, str_hexa);
	i = ft_verif_flags_stock2_4(s_flags, var);
	var->k = s_flags->largeur - s_flags->precision - var->len_str_hexa -
	ft_stock_buf_base(var, s_flags, var->res_strcmp) - var->i_plus - i;
	(var->k < 0) ? var->k = 0 : 0;
	if (var->type == TYPE_BITWISE)
		var->k = s_flags->largeur - var->len_str_hexa;
	if (!ft_strchr(var->flags_stock, '.'))
		ft_memset(&var->buf_tmp[var->i_buf_tmp], '0', var->k);
	else
	{
		ft_memset(&var->buf_tmp[var->i_buf_tmp], ' ',
			s_flags->largeur - var->len_str_hexa);
		var->k = s_flags->largeur - var->len_str_hexa;
	}
	var->i_buf_tmp += var->k;
	ft_memcpy(&var->buf_tmp[var->i_buf_tmp], &str_hexa[var->i_moins],
	var->len_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 %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x4998
movl %eax, 0x80(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x351c
movl %eax, 0x7c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b4c
movl %eax, %ebp
movl 0x4(%r14), %r12d
movl 0x8c(%rbx), %edx
addl 0x8(%r14), %ebp
addl 0x88(%rbx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33ff
addl %ebp, %eax
addl 0x7c(%rbx), %eax
subl %eax, %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovgl %r12d, %eax
movl %eax, 0x90(%rbx)
cmpl $0x12, 0x78(%rbx)
jne 0x36d9
movl 0x4(%r14), %eax
subl 0x88(%rbx), %eax
movl %eax, 0x90(%rbx)
leaq 0x18(%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x3e3c
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
testq %rax, %rax
je 0x371c
movslq 0x4(%r14), %rdx
movslq 0x88(%rbx), %rax
subq %rax, %rdx
pushq $0x20
popq %rsi
callq 0x3f24
movl 0x4(%r14), %ecx
movl 0x88(%rbx), %eax
subl %eax, %ecx
movl %ecx, 0x90(%rbx)
jmp 0x3737
movslq 0x90(%rbx), %rdx
pushq $0x30
popq %rsi
callq 0x3f24
movl 0x88(%rbx), %eax
movl 0x90(%rbx), %ecx
movslq 0x64(%rbx), %rdx
movslq %ecx, %rdi
addq %rdx, %rdi
movl %edi, 0x64(%rbx)
addq 0x10(%rbx), %rdi
movslq 0x80(%rbx), %rcx
addq %rcx, %r15
movslq %eax, %rdx
movq %r15, %rsi
callq 0x3f4c
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 0x3f4c
movl 0x4(%r14), %eax
addl %eax, 0x60(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37d0
testl %r13d, %r13d
je 0x37cd
testb $0x10, (%r14)
je 0x37d0
movl %r15d, %r12d
cmpl %r15d, %ebp
jge 0x37e7
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4998
movl %eax, 0x80(%rbx)
movq (%rsp), %rax
cmpb $0x2d, (%rax)
jne 0x37fa
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 0x3825
andb $0x1, %dl
je 0x3825
addl %r15d, %r13d
subl %r13d, %ebp
cmpl %ecx, %ebp
jge 0x3838
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
pushq $0x20
popq %rsi
callq 0x3f24
movl 0x90(%rbx), %eax
addl %eax, 0x64(%rbx)
movl 0x4(%r14), %eax
cmpl 0x88(%rbx), %eax
jl 0x387c
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4998
movl %eax, 0x80(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x3b84
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 0x3f4c
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_O2/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 0x351c
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
pushq $0x30
popq %rsi
callq 0x3f24
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 0x3f4c
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
pushq $0x20
popq %rsi
callq 0x3f24
movl 0x64(%rbx), %eax
movl 0x88(%rbx), %ecx
addl 0x90(%rbx), %eax
movl %eax, 0x64(%rbx)
testl %ecx, %ecx
je 0x3970
movl %ecx, %ebp
jmp 0x39a8
cmpl $0x0, 0x8(%r14)
jne 0x39a8
movl 0x78(%rbx), %ecx
addl $-0xb, %ecx
cmpl $0x1, %ecx
ja 0x39a8
movslq 0x60(%rbx), %rdi
leal 0x1(%rdi), %eax
movl %eax, 0x60(%rbx)
addq 0x8(%rbx), %rdi
leaq 0x1839(%rip), %rsi      # 0x51d0
pushq $0x1
popq %rdx
callq 0x3f4c
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 0x3f4c
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_O2/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 0x4998
movl %eax, 0x80(%rbx)
movl 0x8c(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33ff
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
pushq $0x30
popq %rsi
callq 0x3f24
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 0x3f4c
movslq 0x60(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movslq 0x64(%rbx), %rax
movslq 0x88(%rbx), %rdx
addq %rax, %rdx
callq 0x3f4c
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 0x3ac6
cmpl $0x0, 0x8(%r14)
jne 0x3ac6
movl 0x78(%rbx), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x3ac6
leal 0x1(%rdi), %eax
movl %eax, 0x60(%rbx)
addq 0x8(%rbx), %rdi
leaq 0x1717(%rip), %rsi      # 0x51d0
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3f4c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b02
movq 0x8(%rbx), %rsi
pushq $0x1
popq %rdi
movl $0x2710, %edx           # imm = 0x2710
callq 0x1040
andl $0x0, 0x60(%rbx)
movq 0x8(%rbx), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x3f38
movslq 0x5c(%rbx), %rax
addq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4529
addl %eax, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3b80
pushq %rbx
movq %rsi, %rbx
movl 0x78(%rsi), %ecx
addl $-0x6, %ecx
cmpl $0x2, %ecx
ja 0x3b7f
movslq 0x64(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x1664(%rip), %rsi      # 0x51d5
pushq $0x1
popq %rdx
callq 0x3f4c
incl 0x64(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x351c
movl 0x8c(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33ff
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
pushq $0x30
popq %rsi
callq 0x3f24
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 0x3f4c
// File: /workspace/github_c_makefile_star2_O2/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 0x3c26
movl 0x4(%rdi), %eax
subl %edx, %eax
addl $-0x2, %eax
jmp 0x3c72
movl 0x8(%rdi), %ecx
cmpl %edx, %ecx
jl 0x3c39
movl 0x4(%rdi), %eax
leal (%rdx,%rcx), %edi
cmpl %edi, %eax
jge 0x3c50
jmp 0x3c70
cmpl $0x0, 0x8c(%rsi)
movl 0x4(%rdi), %eax
je 0x3c49
subl %edx, %eax
jmp 0x3c72
leal (%rdx,%rcx), %edi
cmpl %edi, %eax
jl 0x3c6c
cmpl $0x0, 0x8c(%rsi)
setne %r9b
cmpl $0x12, %r8d
setne %r8b
cmpl %edx, %ecx
jge 0x3c70
andb %r9b, %r8b
jne 0x3c70
subl %ecx, %eax
jmp 0x3c72
subl %edi, %eax
movl %eax, 0x90(%rsi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x10a0
movq %rax, 0x8(%rbx)
movl $0x2710, %edi           # imm = 0x2710
callq 0x10a0
movq %rax, 0x10(%rbx)
andq $0x0, 0x5c(%rbx)
andl $0x0, 0x98(%rbx)
addq $0x4a, %rbx
leaq 0x146a(%rip), %rsi      # 0x5135
movq %rbx, %rdi
popq %rbx
jmp 0x3d88
// File: /workspace/github_c_makefile_star2_O2/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 0x3d54
incq %rdx
cmpb %r8b, %cl
je 0x3d34
movzbl %r8b, %eax
subl %eax, %ecx
movl %ecx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3d20
leaq 0x1(%rax), %rdi
callq 0x10a0
testq %rax, %rax
je 0x3d84
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x3d80
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x3d71
movb $0x0, (%rax,%rcx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3d20
movslq %eax, %rcx
shlq $0x20, %rax
addq %rbx, %rcx
xorl %edx, %edx
movabsq $0x100000000, %rsi      # imm = 0x100000000
movb (%r14,%rdx), %dil
testb %dil, %dil
je 0x3dde
movb %dil, (%rcx,%rdx)
incq %rdx
addq %rsi, %rax
jmp 0x3dc9
sarq $0x20, %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d30
testl %eax, %eax
je 0x3e2f
cmpb $0x0, (%rbx)
je 0x3e2d
xorl %eax, %eax
movb (%r14,%rax), %cl
testb %cl, %cl
je 0x3e2f
leaq 0x1(%rax), %rdx
cmpb (%rbx,%rax), %cl
movq %rdx, %rax
je 0x3e14
incq %rbx
jmp 0x3dfe
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	int				i;

	if (s[0] == c)
		return ((char *)s);
	if (s[0])
	{
		i = 0;
		while (s[i])
		{
			if (s[i] == c)
				return ((char*)&s[i]);
			i++;
		}
		if (s[i] == c)
			return ((char*)&s[i]);
	}
	return (0);
}

// Assembly:
movq %rdi, %rax
movsbl (%rdi), %ecx
cmpl %esi, %ecx
je 0x3e62
testb %cl, %cl
je 0x3e60
movsbl (%rax), %ecx
testl %ecx, %ecx
je 0x3e5c
incq %rax
cmpl %esi, %ecx
jne 0x3e4a
decq %rax
retq
testl %esi, %esi
je 0x3e62
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movabsq $0x100003e00, %rdx      # imm = 0x100003E00
movzbl (%rdi,%rax), %ecx
cmpq $0x20, %rcx
ja 0x3e85
btq %rcx, %rdx
jae 0x3e85
incq %rax
jmp 0x3e70
xorl %edx, %edx
cmpb $0x2d, %cl
sete %dl
xorl %esi, %esi
cmpb $0x2b, %cl
sete %sil
cmpq %rdx, %rsi
cmovaq %rsi, %rdx
addl %edx, %eax
addq %rax, %rdi
xorl %edx, %edx
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3eb9
imull $0xa, %edx, %esi
movzbl %al, %edx
addl %esi, %edx
incq %rdi
jmp 0x3ea4
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_strnew.c
// Function: ft_strnew
char	*ft_strnew(size_t size)
{
	unsigned char	*str;
	size_t			i;

	i = 0;
	if ((str = (unsigned char *)malloc(sizeof(*str) * size + 1)) == 0)
		return (0);
	while (i <= size)
		str[i++] = 0;
	return ((char*)str);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x10a0
testq %rax, %rax
je 0x3ee8
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x3ee8
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x3eda
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
jne 0x3f1e
xorl %ecx, %ecx
pushq $0x1
popq %rax
cmpq %rcx, %rdx
je 0x3f20
movb (%rdi,%rcx), %r8b
movb (%rsi,%rcx), %r9b
movl %r8d, %r10d
orb %r9b, %r10b
je 0x3f20
incq %rcx
cmpb %r9b, %r8b
je 0x3f01
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
negl %ebp
jno 0x3f86
leaq 0x125e(%rip), %rdi      # 0x51d7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3d58
movl %edi, %ebx
cmovsl %edi, %ebp
pushq $-0x1
popq %r14
pushq $0xa
popq %r15
movl %ebp, %eax
cmpl $0xa, %eax
jb 0x3fa4
xorl %edx, %edx
divl %r15d
incq %r14
jmp 0x3f95
xorl %r12d, %r12d
testl %ebx, %ebx
setns %r12b
movl %ebx, %eax
shrl $0x1f, %eax
subl %r12d, %eax
leal (%rax,%r14), %edi
addl $0x4, %edi
callq 0x10a0
testq %rax, %rax
je 0x4021
movq %rax, %rcx
pushq $0x2
popq %rax
subl %r12d, %eax
testl %ebx, %ebx
jne 0x3fd6
movb $0x30, (%rcx)
movl %eax, %edx
movq %rcx, %rsi
addq %rdx, %rsi
movb $0x0, 0x1(%r14,%rsi)
addq %r14, %rsi
addl %eax, %r14d
shlq $0x20, %r14
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
testl %ebp, %ebp
je 0x4012
movl %ebp, %eax
xorl %edx, %edx
divl %r15d
orb $0x30, %dl
movb %dl, (%rsi)
addq %rdi, %r14
decq %rsi
movl %eax, %ebp
jmp 0x3ff8
testl %ebx, %ebx
jns 0x4023
sarq $0x20, %r14
movb $0x2d, (%rcx,%r14)
jmp 0x4023
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4054
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
shrq $0x3f, %rdi
pushq $0xa
popq %rcx
testq %rax, %rax
je 0x4057
xorl %edx, %edx
divq %rcx
incl %edi
jmp 0x4046
pushq $0x1
popq %rdi
movl %edi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %edi, %ebp
cmpl $0xa, %esi
jne 0x4072
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3f64
movl %esi, %ebx
testl %ebp, %ebp
je 0x4089
xorl %r14d, %r14d
movl %ebp, %eax
testl %eax, %eax
jle 0x408d
cltd
idivl %ebx
incq %r14
jmp 0x407d
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testq %r14, %r14
jle 0x40bf
movl %ebp, %eax
cltd
idivl %ebx
leal 0x30(%rdx), %esi
leal 0x57(%rdx), %edi
cmpl $0xa, %edx
cmovll %esi, %edi
movb %dil, -0x1(%rcx,%r14)
decq %r14
movl %eax, %ebp
jmp 0x409d
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %edi, %ebp
cmpl $0xa, %esi
jne 0x40de
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3f64
movl %esi, %ebx
testl %ebp, %ebp
je 0x40f5
xorl %r14d, %r14d
movl %ebp, %eax
testl %eax, %eax
jle 0x40f9
cltd
idivl %ebx
incq %r14
jmp 0x40e9
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%r14)
testq %r14, %r14
jle 0x412b
movl %ebp, %eax
cltd
idivl %ebx
leal 0x30(%rdx), %esi
leal 0x37(%rdx), %edi
cmpl $0xa, %edx
cmovll %esi, %edi
movb %dil, -0x1(%rcx,%r14)
decq %r14
movl %eax, %ebp
jmp 0x4109
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0xa, %esi
jne 0x414e
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4704
movslq %esi, %r15
testq %r14, %r14
je 0x416a
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
jle 0x416d
cqto
idivq %r15
incq %rbx
jmp 0x415b
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x41a3
movq %r14, %rax
cqto
idivq %r15
leal 0x30(%rdx), %esi
leal 0x57(%rdx), %edi
cmpq $0xa, %rdx
cmovll %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x417c
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0xa, %esi
jne 0x41c6
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4704
movslq %esi, %r15
testq %r14, %r14
je 0x41e2
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
jle 0x41e5
cqto
idivq %r15
incq %rbx
jmp 0x41d3
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x421b
movq %r14, %rax
cqto
idivq %r15
leal 0x30(%rdx), %esi
leal 0x37(%rdx), %edi
cmpq $0xa, %rdx
cmovll %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x41f4
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
cmpl $0xa, %esi
jne 0x423e
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x47e0
movslq %esi, %r15
testq %r14, %r14
je 0x425a
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
je 0x425d
xorl %edx, %edx
divq %r15
incq %rbx
jmp 0x424b
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x4293
movq %r14, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %esi
leal 0x57(%rdx), %edi
cmpq $0xa, %rdx
cmovbl %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x426c
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
cmpl $0xa, %esi
jne 0x42b6
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x47e0
movslq %esi, %r15
testq %r14, %r14
je 0x42d2
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
je 0x42d5
xorl %edx, %edx
divq %r15
incq %rbx
jmp 0x42c3
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x430b
movq %r14, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %esi
leal 0x37(%rdx), %edi
cmpq $0xa, %rdx
cmovbl %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x42e4
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0xa, %esi
jne 0x432e
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4858
movslq %esi, %r15
testq %r14, %r14
je 0x434a
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
jle 0x434d
cqto
idivq %r15
incq %rbx
jmp 0x433b
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x4383
movq %r14, %rax
cqto
idivq %r15
leal 0x30(%rdx), %esi
leal 0x57(%rdx), %edi
cmpq $0xa, %rdx
cmovll %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x435c
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %r14
cmpl $0xa, %esi
jne 0x43a6
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x47e0
movslq %esi, %r15
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
je 0x43bd
xorl %edx, %edx
divq %r15
incq %rbx
jmp 0x43ae
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x43f3
movq %r14, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %esi
leal 0x57(%rdx), %edi
cmpq $0xa, %rdx
cmovbl %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x43cc
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %r14
cmpl $0xa, %esi
jne 0x4416
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x492c
movslq %esi, %r15
xorl %ebx, %ebx
movq %r14, %rax
testq %rax, %rax
je 0x442d
xorl %edx, %edx
divq %r15
incq %rbx
jmp 0x441e
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rcx
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
jle 0x4463
movq %r14, %rax
xorl %edx, %edx
divq %r15
leal 0x30(%rdx), %esi
leal 0x37(%rdx), %edi
cmpq $0xa, %rdx
cmovbl %esi, %edi
movb %dil, -0x1(%rcx,%rbx)
decq %rbx
movq %rax, %r14
jmp 0x443c
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4493
movl %r15d, %eax
movabsq $0x1682900000000, %rcx  # imm = 0x1682900000000
btq %rax, %rcx
jb 0x44a6
leal -0x68(%r15), %eax
cmpl $0x12, %eax
ja 0x44b3
movl $0x40015, %ecx          # imm = 0x40015
btl %eax, %ecx
jae 0x44b3
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 0x3e3c
testq %rax, %rax
jne 0x44a6
movl %ebp, %edi
callq 0x49b8
testl %eax, %eax
jne 0x44a6
movb %r15b, 0x70(%r14)
leaq 0x7(%rsp), %rax
movq %rax, (%r14)
pushq $0x1
popq %rbx
jmp 0x44a6
// File: /workspace/github_c_makefile_star2_O2/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 0x446c
testl %eax, %eax
je 0x4521
pushq $0x4e
popq %rsi
movq %r15, %rdi
callq 0x4683
movslq (%rbx), %rax
cmpb $0x0, 0x1(%r14,%rax)
je 0x4523
incq %rax
movl %eax, (%rbx)
jmp 0x4523
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq