LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: infect
char	*infect(t_env *env, int elf_len, char* payload, int payload_len)
{
  Elf64_Addr	entry;
  Elf64_Addr	payload_vaddr;
  Elf64_Addr	text_end;
  char		*new_file;
  int		jmp_len;

  char jmp_entry[] = "\x48\xb8\x41\x41\x41\x41\x41\x41\x41\x41" //mov rax,0x4141414141414141
    "\xff\xe0"; // jmp rax
  jmp_len = 12;
  new_file = malloc(elf_len + PAGE_SZ64);
  payload_len += jmp_len;
  entry = env->elf64->e_entry;
  payload_vaddr = infect_segment(env, &text_end);
  infect_section(env, text_end, payload_vaddr);
  memcpy(&jmp_entry[2], (char*)&entry, 8);
  memcpy(new_file, env->ptr, (size_t) text_end);
  memcpy(new_file + text_end, payload, payload_len - jmp_len);
  memcpy(new_file + text_end + payload_len - jmp_len, jmp_entry, jmp_len);
  memcpy(new_file + text_end + PAGE_SZ64, env->ptr + text_end, elf_len - text_end);

  return new_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x8637(%rip), %rax      # 0xa0c4
movq %rax, -0x51(%rbp)
movl 0x8635(%rip), %eax      # 0xa0cc
movl %eax, -0x49(%rbp)
movb 0x8630(%rip), %al       # 0xa0d0
movb %al, -0x45(%rbp)
movl $0xc, -0x44(%rbp)
movl -0xc(%rbp), %eax
addl $0x2000, %eax           # imm = 0x2000
movslq %eax, %rdi
callq 0x10a0
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x17c0
movq -0x28(%rbp), %rax
movq %rax, -0x4f(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x1090
movq -0x40(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl -0x44(%rbp), %eax
movslq %eax, %rdx
callq 0x1090
movq -0x40(%rbp), %rdi
addq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movslq -0x44(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
leaq -0x51(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x1090
movq -0x40(%rbp), %rdi
addq -0x38(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rsi
addq -0x38(%rbp), %rsi
movslq -0xc(%rbp), %rdx
subq -0x38(%rbp), %rdx
callq 0x1090
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: inject
int	inject(t_env *env)
{
  char	*new_file;
  int	fd;

  new_file = infect(env, env->buf.st_size,
  env->ptr_payload + env->sec64->sh_offset, env->sec64->sh_size);
  if ((fd = open(env->name_output, O_RDWR | O_CREAT,
  S_IRWXU | S_IRWXG | S_IRWXO)) < 0)
    return (2);
  write(fd, new_file, env->buf.st_size + PAGE_SZ64);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
addq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq 0x20(%rax), %rax
movl %eax, %ecx
callq 0x1a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x42, %esi
movl $0x1ff, %edx            # imm = 0x1FF
movb $0x0, %al
callq 0x10c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x1c17
movl $0x2, -0x4(%rbp)
jmp 0x1c39
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
addq $0x2000, %rdx           # imm = 0x2000
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_printf.c
// Function: ft_color
static int			ft_color(const char *format, t_var *var)
{
	const char		*reset_color = "\033[0m";
	int				i;

	i = -1;
	if (ft_strnequ("{eoc}", &format[0], 5))
	{
		ft_memcpy(&var->buf[var->i_buf], reset_color,
			var->i_buf += ft_strlen(reset_color));
		var->ret += 5;
	}
	if (ft_strstr(format, "{eoc}"))
	{
		while (g_color[++i].color)
		{
			if (ft_strnequ(g_color[i].color, &format[0],
						ft_strlen(g_color[i].color)))
			{
				ft_memcpy(&var->buf[var->i_buf], g_color[i].unicode,
					var->i_buf += ft_strlen(g_color[i].unicode));
				var->ret += ft_strlen(g_color[i].color);
				return (0);
			}
		}
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x827a(%rip), %rax      # 0xa0d1
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rsi
leaq 0x8269(%rip), %rdi      # 0xa0d6
movl $0x5, %edx
callq 0x7460
cmpl $0x0, %eax
je 0x1ed2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x60(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6ef0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movslq 0x60(%rcx), %rax
addq %rdx, %rax
movl %eax, 0x60(%rcx)
movslq %eax, %rdx
callq 0x75c0
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0x5c(%rax)
movq -0x10(%rbp), %rdi
leaq 0x81f9(%rip), %rsi      # 0xa0d6
callq 0x7130
cmpq $0x0, %rax
je 0x200e
jmp 0x1eee
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movslq %eax, %rcx
leaq 0xae6f(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x200c
movslq -0x24(%rbp), %rcx
leaq 0xae53(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0xae32(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x6ef0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x7460
cmpl $0x0, %eax
je 0x2007
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x60(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0xade8(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0xadce(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x6ef0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movslq 0x60(%rcx), %rax
addq %rdx, %rax
movl %eax, 0x60(%rcx)
movslq %eax, %rdx
callq 0x75c0
movslq -0x24(%rbp), %rcx
leaq 0xad92(%rip), %rax      # 0xcd70
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x6ef0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq 0x5c(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x5c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2015
jmp 0x1eee
jmp 0x200e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_printf.c
// Function: ft_fd
static int			ft_fd(const char *format, t_var *var)
{
	static int		i = 0;

	if (ft_strnequ("{fd}", &format[0], 4))
	{
		if (format[4] >= '0' && format[4] <= '9')
		{
			var->ret += 6;
			i = 1;
			var->fd = ft_atoi(&format[4]);
		}
		else
			var->ret += 5;
	}
	else if (i == 0)
		var->fd = 1;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x8102(%rip), %rdi      # 0xa13d
movl $0x4, %edx
callq 0x7460
cmpl $0x0, %eax
je 0x20a5
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x30, %eax
jl 0x2096
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x39, %eax
jg 0x2096
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x6, %ecx
movl %ecx, 0x5c(%rax)
movl $0x1, 0xb011(%rip)      # 0xd08c
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x7280
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x94(%rax)
jmp 0x20a3
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0x5c(%rax)
jmp 0x20be
cmpl $0x0, 0xafe0(%rip)      # 0xd08c
jne 0x20bc
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
jmp 0x20be
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_printf.c
// Function: ft_printf
int					ft_printf(const char *format, ...)
{
	t_var			var;
	va_list			ap;

	ft_init_var(&var);
	va_start(ap, format);
	if (ft_return_printf2(format, ap, &var))
		return (-1);
	if (ft_verif_wchar_nb(&var))
		return (-1);
	else if (var.type == TYPE_WCHAR && var.nb_conv && var.nb.u_i > 1114111)
	{
		var.ret = var.ret - 1 - ft_strlen(var.flags_stock) - 1;
		while (format[var.ret--] != '%')
			var.i_buf--;
		var.i_buf++;
		write(var.fd, var.buf, var.i_buf);
		ft_free(&var);
		return (-1);
	}
	va_end(ap);
	write(var.fd, var.buf, var.i_buf);
	ft_free(&var);
	return (var.i_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
testb %al, %al
je 0x2167
movaps %xmm0, -0x150(%rbp)
movaps %xmm1, -0x140(%rbp)
movaps %xmm2, -0x130(%rbp)
movaps %xmm3, -0x120(%rbp)
movaps %xmm4, -0x110(%rbp)
movaps %xmm5, -0x100(%rbp)
movaps %xmm6, -0xf0(%rbp)
movaps %xmm7, -0xe0(%rbp)
movq %r9, -0x158(%rbp)
movq %r8, -0x160(%rbp)
movq %rcx, -0x168(%rbp)
movq %rdx, -0x170(%rbp)
movq %rsi, -0x178(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6dc0
leaq -0xd0(%rbp), %rax
leaq -0x180(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x6ea0
cmpl $0x0, %eax
je 0x21e9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22df
leaq -0xb0(%rbp), %rdi
callq 0x6e40
cmpl $0x0, %eax
je 0x2206
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22df
cmpl $0x3, -0x38(%rbp)
jne 0x22b1
cmpl $0x0, -0x18(%rbp)
je 0x22b1
cmpl $0x10ffff, -0x40(%rbp)  # imm = 0x10FFFF
jbe 0x22b1
movl -0x54(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x188(%rbp)
leaq -0xb0(%rbp), %rdi
addq $0x18, %rdi
callq 0x6ef0
movq %rax, %rcx
movq -0x188(%rbp), %rax
subq %rcx, %rax
subq $0x1, %rax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x54(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
je 0x2280
movl -0x50(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x225a
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x1c(%rbp), %edi
movq -0xa8(%rbp), %rsi
movslq -0x50(%rbp), %rdx
callq 0x1040
leaq -0xb0(%rbp), %rdi
callq 0x6d90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22df
jmp 0x22b3
leaq -0xd0(%rbp), %rax
movl -0x1c(%rbp), %edi
movq -0xa8(%rbp), %rsi
movslq -0x50(%rbp), %rdx
callq 0x1040
leaq -0xb0(%rbp), %rdi
callq 0x6d90
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags.c
// Function: ft_flags
int					ft_flags(char *flags, t_flags *s_flags)
{
	int				i;

	i = 0;
	if (flags[0] == 0)
		return (0);
	s_flags->c = 0;
	while (flags[i] && (!(flags[i] >= '1' && flags[i] <= '9')) &&
		flags[i] != '.' && ft_verif_mod(flags[i]))
	{
		if (flags[i] == '0')
			s_flags->c = s_flags->c | (1 << 0);
		if (flags[i] == '+')
			s_flags->c = s_flags->c | (1 << 1);
		if (flags[i] == '-')
			s_flags->c = s_flags->c | (1 << 2);
		if (flags[i] == ' ')
			s_flags->c = s_flags->c | (1 << 3);
		if (flags[i] == '#')
			s_flags->c = s_flags->c | (1 << 4);
		i++;
	}
	ft_flags2(flags, s_flags, &i);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2bff
movl $0x0, -0x4(%rbp)
jmp 0x2d54
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x2c73
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jl 0x2c43
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x39, %ecx
movb %al, -0x1d(%rbp)
jle 0x2c73
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x1d(%rbp)
je 0x2c73
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2d60
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x2c7f
jmp 0x2d3c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x2ca2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
orl $0x1, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x2cc5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
orl $0x2, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x2ce8
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
orl $0x4, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x2d0b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
orl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x23, %eax
jne 0x2d2e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
orl $0x10, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c06
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x2dc0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags.c
// Function: ft_verif_mod
static int			ft_verif_mod(char c)
{
	if (c == 'h')
		return (0);
	if (c == 'l')
		return (0);
	if (c == 'j')
		return (0);
	if (c == 'z')
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x68, %eax
jne 0x2d7c
movl $0x0, -0x4(%rbp)
jmp 0x2db9
movsbl -0x5(%rbp), %eax
cmpl $0x6c, %eax
jne 0x2d8e
movl $0x0, -0x4(%rbp)
jmp 0x2db9
movsbl -0x5(%rbp), %eax
cmpl $0x6a, %eax
jne 0x2da0
movl $0x0, -0x4(%rbp)
jmp 0x2db9
movsbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jne 0x2db2
movl $0x0, -0x4(%rbp)
jmp 0x2db9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags.c
// Function: ft_flags2
static void			ft_flags2(char *flags, t_flags *s_flags, int *i)
{
	int				u;

	s_flags->largeur = ft_atoi(&flags[*i]);
	if (s_flags->largeur < 0)
		s_flags->largeur = 0;
	*i += (flags[*i] >= '0' && flags[*i] <= '9') ?
		ft_is_number(ft_atoi(&flags[*i])) : 0;
	s_flags->precision = (flags[*i] == '.') ? ft_atoi(&flags[*i + 1]) : 0;
	if (s_flags->precision < 0)
		s_flags->precision = 0;
	u = ft_is_number(ft_atoi(&flags[*i + 1]));
	*i += (flags[*i] == '.') ? u : 0;
	ft_verif_modificateur(&flags[*i], s_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdi
callq 0x7280
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x2e05
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x2e4d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x2e4d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdi
callq 0x7280
movslq %eax, %rdi
callq 0x77e0
movl %eax, -0x20(%rbp)
jmp 0x2e54
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x2e54
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2e8f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
callq 0x7280
movl %eax, -0x24(%rbp)
jmp 0x2e96
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x2e96
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x2eb5
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
callq 0x7280
movslq %eax, %rdi
callq 0x77e0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2ef3
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2efa
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x2efa
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags.c
// Function: ft_verif_modificateur
static void			ft_verif_modificateur(char *mod, t_flags *s_flags)
{
	s_flags->m = 0;
	if (ft_strstr(mod, "hh"))
		s_flags->m = s_flags->m | (1 << 0);
	else if (ft_strstr(mod, "h"))
		s_flags->m = s_flags->m | (1 << 1);
	else if (ft_strstr(mod, "ll"))
		s_flags->m = s_flags->m | (1 << 3);
	else if (ft_strstr(mod, "l"))
		s_flags->m = s_flags->m | (1 << 2);
	else if (ft_strstr(mod, "j"))
		s_flags->m = s_flags->m | (1 << 4);
	else if (ft_strstr(mod, "z"))
		s_flags->m = s_flags->m | (1 << 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
leaq 0x7209(%rip), %rsi      # 0xa15c
callq 0x7130
cmpq $0x0, %rax
je 0x2f77
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x1, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x3061
movq -0x8(%rbp), %rdi
leaq 0x71db(%rip), %rsi      # 0xa15d
callq 0x7130
cmpq $0x0, %rax
je 0x2fa6
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x2, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x305f
movq -0x8(%rbp), %rdi
leaq 0x71ae(%rip), %rsi      # 0xa15f
callq 0x7130
cmpq $0x0, %rax
je 0x2fd5
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x305d
movq -0x8(%rbp), %rdi
leaq 0x7180(%rip), %rsi      # 0xa160
callq 0x7130
cmpq $0x0, %rax
je 0x3001
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x4, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x305b
movq -0x8(%rbp), %rdi
leaq 0x7156(%rip), %rsi      # 0xa162
callq 0x7130
cmpq $0x0, %rax
je 0x302d
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x3059
movq -0x8(%rbp), %rdi
leaq 0x712c(%rip), %rsi      # 0xa164
callq 0x7130
cmpq $0x0, %rax
je 0x3057
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
orl $0x20, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
jmp 0x3059
jmp 0x305b
jmp 0x305d
jmp 0x305f
jmp 0x3061
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_print_flags_buffer.c
// Function: ft_print_flags_buffer
int				ft_print_flags_buffer(va_list ap, t_var *var, t_flags *s_flags)
{
	if (var->type >= TYPE_NON_CONNU && var->type <= TYPE_WSTRING)
		ft_print_flags_buffer2(ap, var, s_flags);
	else
	{
		if (var->type == TYPE_ADDRESS)
			ft_flags_stock(var, s_flags,
						ft_lltoa_base(va_arg(ap, unsigned long), 16));
		else if (var->type == TYPE_HEXA)
			ft_conv_envoi(ap, var, s_flags, 16);
		else if (var->type == TYPE_HEXA_MAJ)
			ft_conv_envoi_maj(ap, var, s_flags, 16);
		else if (var->type == TYPE_OCTAL)
			ft_conv_envoi(ap, var, s_flags, 8);
		else if (var->type == TYPE_OCTAL_MAJ)
			ft_conv_envoi_maj(ap, var, s_flags, 8);
		else if (var->type == TYPE_BITWISE)
			ft_conv_envoi(ap, var, s_flags, 2);
		else
			ft_conv_envoi(ap, var, s_flags, 10);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jl 0x30ae
movq -0x10(%rbp), %rax
cmpl $0x5, 0x78(%rax)
jg 0x30ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3210
jmp 0x3202
movq -0x10(%rbp), %rax
cmpl $0xf, 0x78(%rax)
jne 0x3130
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x30f3
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x310a
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl $0x10, %esi
callq 0x7d70
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3770
jmp 0x3200
movq -0x10(%rbp), %rax
cmpl $0xd, 0x78(%rax)
jne 0x3155
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %ecx
callq 0x51a0
jmp 0x31fe
movq -0x10(%rbp), %rax
cmpl $0xe, 0x78(%rax)
jne 0x317a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %ecx
callq 0x4720
jmp 0x31fc
movq -0x10(%rbp), %rax
cmpl $0xb, 0x78(%rax)
jne 0x319c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq 0x51a0
jmp 0x31fa
movq -0x10(%rbp), %rax
cmpl $0xc, 0x78(%rax)
jne 0x31be
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq 0x4720
jmp 0x31f8
movq -0x10(%rbp), %rax
cmpl $0x12, 0x78(%rax)
jne 0x31e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x2, %ecx
callq 0x51a0
jmp 0x31f6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0xa, %ecx
callq 0x51a0
jmp 0x31f8
jmp 0x31fa
jmp 0x31fc
jmp 0x31fe
jmp 0x3200
jmp 0x3202
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_print_flags_buffer.c
// Function: ft_print_flags_buffer2
static void		ft_print_flags_buffer2(va_list ap, t_var *var, t_flags *s_flags)
{
	var->res = NULL;
	var->i_buf_tmp = 0;
	if (var->type == TYPE_MODULO)
	{
		var->nb.c = '%';
		var->res = &var->nb.c;
		var->res[1] = 0;
	}
	else if (var->type == TYPE_CHAR && s_flags->m == 0)
	{
		var->nb.c = va_arg(ap, int);
		var->res = &var->nb.c;
		var->res[1] = 0;
	}
	else if (var->type == TYPE_STRING && s_flags->m == 0)
		var->res = va_arg(ap, char*);
	else
	{
		ft_print_flags_buffer3(ap, var, s_flags, 0);
		return ;
	}
	ft_print_flags_buffer4(var, s_flags, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x78(%rax)
jne 0x326b
movq -0x10(%rbp), %rax
movb $0x25, 0x70(%rax)
movq -0x10(%rbp), %rcx
addq $0x70, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x1(%rax)
jmp 0x3374
movq -0x10(%rbp), %rax
cmpl $0x2, 0x78(%rax)
jne 0x32f2
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0x32f2
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x32ad
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x32c4
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x70(%rax)
movq -0x10(%rbp), %rcx
addq $0x70, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x1(%rax)
jmp 0x3372
movq -0x10(%rbp), %rax
cmpl $0x4, 0x78(%rax)
jne 0x335b
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0x335b
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x28, %eax
ja 0x3334
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x48(%rbp)
jmp 0x334b
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3370
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3390
jmp 0x3383
jmp 0x3372
jmp 0x3374
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3560
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_print_flags_buffer.c
// Function: ft_print_flags_buffer4
static void		ft_print_flags_buffer4(t_var *var, t_flags *s_flags, int res)
{
	char		tab[6];

	if (var->res)
	{
		if (s_flags->precision < (int)ft_strlen(var->res))
			ft_flags_precision(var, s_flags, 0);
		else
			ft_flags_largeur(var, s_flags, 0);
	}
	else
	{
		var->res = ((var->type == TYPE_STRING || var->type == TYPE_WSTRING) &&
					!(s_flags->c & (1 << 0))) ? ft_strcpy(tab, "(null)") : 0;
		ft_flags_precision(var, s_flags, 0);
	}
	if (var->type == TYPE_WCHAR || (var->type == TYPE_CHAR && s_flags->m > 2 &&
									s_flags->m <= 16))
	{
		if (s_flags->largeur > res)
			ft_wchar2(var->nb.chr, var, res);
		else
			ft_wchar2(var->nb.chr, var, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x35bf
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6ef0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x35ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x5610
jmp 0x35bd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x58c0
jmp 0x361a
movq -0x8(%rbp), %rax
cmpl $0x4, 0x78(%rax)
je 0x35d3
movq -0x8(%rbp), %rax
cmpl $0x5, 0x78(%rax)
jne 0x35f8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x35f8
leaq -0x1a(%rbp), %rdi
leaq 0x6b65(%rip), %rsi      # 0xa152
callq 0x7050
movq %rax, -0x28(%rbp)
jmp 0x3600
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3600
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x5610
movq -0x8(%rbp), %rax
cmpl $0x3, 0x78(%rax)
je 0x3648
movq -0x8(%rbp), %rax
cmpl $0x2, 0x78(%rax)
jne 0x367d
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x2, %eax
jle 0x367d
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x10, %eax
jg 0x367d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x3669
movq -0x8(%rbp), %rax
movl 0x70(%rax), %edi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3e50
jmp 0x367b
movq -0x8(%rbp), %rax
movl 0x70(%rax), %edi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x3e50
jmp 0x367d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_print_flags_buffer.c
// Function: ft_print_flags_buffer5
static void		ft_print_flags_buffer5(t_var *var, int i)
{
	while (var->nb.chr2[i])
		var->res2 += ft_wstrlen(var->nb.chr2[i++]);
	var->res = ft_strnew(var->res2);
	i = 0;
	while (var->nb.chr2[i])
		ft_strcat(var->res, ft_wchar(var->nb.chr2[i++]));
	var->res[var->res2] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x36e3
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edi
callq 0x4180
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x9c(%rax), %ecx
movl %ecx, 0x9c(%rax)
jmp 0x369f
movq -0x8(%rbp), %rax
movslq 0x9c(%rax), %rdi
callq 0x73f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x374d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edi
callq 0x4060
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x70b0
jmp 0x3704
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x9c(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock.c
// Function: ft_flags_stock
void		ft_flags_stock(t_var *var, t_flags *s_flags, char *str_hexa)
{
	var->res_strcmp = ft_strcmp(str_hexa, "0");
	var->len_str_hexa = ft_strlen(str_hexa);
	var->i_buf_tmp = 0;
	var->i_moins = 0;
	if (s_flags->c == 8 && s_flags->m == 0 && !s_flags->largeur &&
		!s_flags->precision && (var->type == TYPE_SHORT ||
		var->type == TYPE_INT ||
		var->type == TYPE_SHORT_MAJ) && str_hexa[0] != '-')
		var->buf[var->i_buf++] = ' ';
	if (s_flags->precision >= s_flags->largeur && s_flags->precision >=
		var->len_str_hexa)
		ft_flags_stock2_1(var, s_flags, str_hexa);
	else
		ft_flags_stock2(var, s_flags, str_hexa);
	free(str_hexa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x69d7(%rip), %rsi      # 0xa166
callq 0x6f20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x18(%rbp), %rdi
callq 0x6ef0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x8, %eax
jne 0x3843
movq -0x10(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0x3843
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x3843
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3843
movq -0x8(%rbp), %rax
cmpl $0x6, 0x78(%rax)
je 0x3819
movq -0x8(%rbp), %rax
cmpl $0x7, 0x78(%rax)
je 0x3819
movq -0x8(%rbp), %rax
cmpl $0x8, 0x78(%rax)
jne 0x3843
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3843
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x60(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x60(%rdx)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x3879
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jl 0x3879
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6860
jmp 0x388a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x38a0
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock.c
// Function: ft_flags_stock2
static void	ft_flags_stock2(t_var *var, t_flags *s_flags, char *str_hexa)
{
	if (s_flags->largeur > s_flags->precision && s_flags->precision >=
		var->len_str_hexa)
	{
		if ((s_flags->c & (1 << 2)))
			ft_flags_stock2_21(var, s_flags, str_hexa);
		else
			ft_flags_stock2_2(var, s_flags, str_hexa);
	}
	else
		ft_flags_stock3(var, s_flags, str_hexa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x390c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jl 0x390c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x38f9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6640
jmp 0x390a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6400
jmp 0x391d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3930
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_stock.c
// Function: ft_flags_stock5
static void	ft_flags_stock5(t_var *var, t_flags *s_flags, char *str_hexa)
{
	if ((s_flags->c & (1 << 4)))
	{
		var->k = s_flags->largeur - var->len_str_hexa -
			ft_stock_buf_base(var, s_flags, var->res_strcmp);
		(var->k < 0) ? var->k = 0 : 0;
		ft_memset(&var->buf_tmp[0], ' ', var->k);
		var->i_buf_tmp = var->k;
		ft_stock_buf_base(var, s_flags, var->res_strcmp);
		ft_memcpy(&var->buf_tmp[var->i_buf_tmp], str_hexa,
			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;
	}
	else
		ft_flags_stock2_5(var, s_flags, str_hexa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3e37
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x88(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %edx
callq 0x5cd0
movl -0x1c(%rbp), %ecx
subl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jge 0x3d6e
movq -0x8(%rbp), %rax
movl $0x0, 0x90(%rax)
jmp 0x3d70
jmp 0x3d70
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x90(%rax), %rdx
movl $0x20, %esi
callq 0x7530
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %edx
callq 0x5cd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x64(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq 0x88(%rax), %rdx
callq 0x75c0
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x64(%rax), %ecx
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x60(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x64(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x88(%rcx), %eax
movslq %eax, %rdx
callq 0x75c0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x60(%rax), %ecx
movl %ecx, 0x60(%rax)
jmp 0x3e48
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5f80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_wchar.c
// Function: ft_wchar
char		*ft_wchar(wchar_t chr)
{
	char	*c;

	c = ft_strnew(4);
	if (chr <= 127)
		c[0] = chr;
	else if (chr <= 2047)
	{
		c[0] = (chr >> 6) + 192;
		c[1] = (chr & 63) + 128;
	}
	else if (chr <= 65535)
	{
		c[0] = (chr >> 12) + 224;
		c[1] = ((chr >> 6) & 63) + 128;
		c[2] = (chr & 63) + 128;
	}
	else if (chr <= 1114111)
	{
		c[0] = (chr >> 18) + 240;
		c[1] = ((chr >> 12) & 63) + 128;
		c[2] = ((chr >> 6) & 63) + 128;
		c[3] = (chr & 63) + 128;
	}
	return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x4, %edi
callq 0x73f0
movq %rax, -0x10(%rbp)
cmpl $0x7f, -0x4(%rbp)
jg 0x408f
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x4171
cmpl $0x7ff, -0x4(%rbp)      # imm = 0x7FF
jg 0x40c4
movl -0x4(%rbp), %eax
sarl $0x6, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
jmp 0x416f
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jg 0x410d
movl -0x4(%rbp), %eax
sarl $0xc, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0x416d
cmpl $0x10ffff, -0x4(%rbp)   # imm = 0x10FFFF
jg 0x416b
movl -0x4(%rbp), %eax
sarl $0x12, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x4(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
jmp 0x416d
jmp 0x416f
jmp 0x4171
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_wstrlen.c
// Function: ft_wstrlen
int	ft_wstrlen(wchar_t chr)
{
	if (chr <= 0x7F)
		return (1);
	else if (chr <= 0x7FF)
		return (2);
	else if (chr <= 0xFFFF)
		return (3);
	else if (chr <= 0x10FFFF)
		return (4);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x7f, -0x8(%rbp)
jg 0x4196
movl $0x1, -0x4(%rbp)
jmp 0x41d9
cmpl $0x7ff, -0x8(%rbp)      # imm = 0x7FF
jg 0x41a8
movl $0x2, -0x4(%rbp)
jmp 0x41d9
cmpl $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jg 0x41ba
movl $0x3, -0x4(%rbp)
jmp 0x41d9
cmpl $0x10ffff, -0x8(%rbp)   # imm = 0x10FFFF
jg 0x41cc
movl $0x4, -0x4(%rbp)
jmp 0x41d9
jmp 0x41ce
jmp 0x41d0
jmp 0x41d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi_maj.c
// Function: ft_conv_envoi_maj3
void	ft_conv_envoi_maj3(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 5)))
		ft_flags_stock(var, s_flags,
						ft_ltoa_base_maj(va_arg(ap, size_t), base));
	else
	{
		if (var->type <= TYPE_INT && s_flags->m == 0)
			ft_flags_stock(var, s_flags,
						ft_itoa_base_maj(va_arg(ap, int), base));
		else
			ft_flags_stock(var, s_flags,
					ft_lltoa_base_maj(va_arg(ap, unsigned int), base));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4280
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x28, %eax
ja 0x4245
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x425c
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x7c10
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3770
jmp 0x4393
movq -0x10(%rbp), %rax
cmpl $0x7, 0x78(%rax)
jg 0x4310
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0x4310
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x28, %eax
ja 0x42d6
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x42ed
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl (%rax), %edi
movl -0x1c(%rbp), %esi
callq 0x7980
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x3770
jmp 0x4391
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x28, %eax
ja 0x4351
movq -0x78(%rbp), %rcx
movl -0x6c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x90(%rbp)
jmp 0x436b
movq -0x78(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movl -0x1c(%rbp), %esi
callq 0x7eb0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x3770
jmp 0x4393
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags_largeur.c
// Function: ft_flags_precision2
static void		ft_flags_precision2(t_var *var, int i)
{
	while (i < (int)ft_strlen(var->buf_tmp))
		var->buf[var->i_buf++] = var->buf_tmp[i++];
	if (var->type == TYPE_CHAR && !var->nb.c && ft_strlen(var->buf_tmp))
		var->buf[var->i_buf - 1] = var->nb.c;
	else if (var->type == TYPE_CHAR && !var->nb.c && !ft_strlen(var->buf_tmp))
		var->buf[var->i_buf++] = var->nb.c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6ef0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x5824
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x60(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x60(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x57cf
movq -0x8(%rbp), %rax
cmpl $0x2, 0x78(%rax)
jne 0x586c
movq -0x8(%rbp), %rax
cmpb $0x0, 0x70(%rax)
jne 0x586c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6ef0
cmpq $0x0, %rax
je 0x586c
movq -0x8(%rbp), %rax
movb 0x70(%rax), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x60(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x58b9
movq -0x8(%rbp), %rax
cmpl $0x2, 0x78(%rax)
jne 0x58b7
movq -0x8(%rbp), %rax
cmpb $0x0, 0x70(%rax)
jne 0x58b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6ef0
cmpq $0x0, %rax
jne 0x58b7
movq -0x8(%rbp), %rax
movb 0x70(%rax), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x60(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x60(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x58b9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6ef0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jge 0x58fb
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
jmp 0x5962
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jl 0x5936
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x591d
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x592a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
jmp 0x5960
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x594c
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x5956
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
jmp 0x5962
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x64(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x75c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x59b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x64(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0x18(%rbp), %rdx
callq 0x75c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x59d5
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6ef0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x5a02
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x64(%rax), %ecx
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x5a20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)