LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/exec.c
// Function: exec
int		exec(t_info_shell *shell, char *valid_path)
{
  pid_t		pid;
  int		status;

  pid = fork();
  if (pid == -1)
    return (84);
  if (pid == 0)
    {
      if (valid_path == NULL)
	{
	  my_printf("%s: %s", shell->tab[0], COMMAND_ERROR);
	  exit(EXIT_ERROR);
	}
      execve(valid_path, shell->tab, environ);
      exit(handle_error(valid_path));
    }
  else
    {
      waitpid(pid, &status, WUNTRACED);
      return (get_signals(status));
    }
  return (EXIT_ERROR);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x54, %ebp
callq 0x21f0
cmpl $-0x1, %eax
je 0x3445
testl %eax, %eax
je 0x3450
leaq 0xc(%rsp), %rbx
movl %eax, %edi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x2150
movl (%rbx), %eax
movl %eax, %ecx
andl $0x7f, %ecx
cmpl $0x8, %ecx
je 0x340b
cmpl $0xb, %ecx
jne 0x3418
testb %al, %al
js 0x341d
leaq 0x3e5e(%rip), %rdi      # 0x7267
jmp 0x3424
testb %al, %al
js 0x3432
leaq 0x3e87(%rip), %rdi      # 0x729d
jmp 0x3439
movzbl %ah, %ebp
jmp 0x3445
leaq 0x3e21(%rip), %rdi      # 0x7245
xorl %eax, %eax
callq 0x5bb6
movl $0x8b, %ebp
jmp 0x3445
leaq 0x3e42(%rip), %rdi      # 0x727b
xorl %eax, %eax
callq 0x5bb6
movl $0x88, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%r14), %rsi
testq %rbx, %rbx
jne 0x3473
movq (%rsi), %rsi
leaq 0x3d81(%rip), %rdi      # 0x71e4
leaq 0x3d81(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5bb6
jmp 0x348d
movq 0x7b6e(%rip), %rax      # 0xafe8
movq (%rax), %rdx
movq %rbx, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x3497
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/exec.c
// Function: handle_error
static int	handle_error(char *command)
{
  if (errno == ENOEXEC)
    my_printf("%s: %s %s\n", command, EXEC_ERROR, BINARY_ERROR);
  if (errno == EACCES)
    my_printf("%s: %s", command, PERM_ERROR);
  return (EXIT_ERROR);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2040
movq %rax, %r14
movl (%rax), %eax
cmpl $0x8, %eax
jne 0x34cf
leaq 0x3d4b(%rip), %rdi      # 0x71ff
leaq 0x3d4f(%rip), %rdx      # 0x720a
leaq 0x3d5b(%rip), %rcx      # 0x721d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5bb6
movl (%r14), %eax
cmpl $0xd, %eax
jne 0x34f3
leaq 0x3d09(%rip), %rdi      # 0x71e4
leaq 0x3d4f(%rip), %rdx      # 0x7231
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5bb6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/find_flags.c
// Function: find_flags
int		find_flags(t_info_shell *shell)
{
  int		i;
  int		j;

  i = 0;
  while (shell->tab[i] != NULL)
    {
      j = 0;
      while (j < 9)
        {
          if ((my_strcmp(shell->tab[i], g_flags[j].code)) == 0)
            {
              if ((g_flags[j].fc(shell)) == 84)
		return (84);
              return (0);
            }
          j += 1;
        }
      i += 1;
    }
  shell->flags_value = 0;
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $0x0, (%rax)
je 0x3554
xorl %r15d, %r15d
leaq 0x7705(%rip), %r14      # 0xac20
movl $0x8, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq -0x8(%r12,%r14), %rsi
callq 0x4752
testl %eax, %eax
je 0x355f
addq $0x10, %r12
cmpq $0x98, %r12
jne 0x3521
movq 0x18(%rbx), %rax
cmpq $0x0, 0x8(%rax,%r15,8)
leaq 0x1(%r15), %r15
jne 0x351b
movl $0x0, 0x40(%rbx)
xorl %eax, %eax
jmp 0x3570
movq %rbx, %rdi
callq *(%r12,%r14)
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x54, %ecx
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/parsing.c
// Function: parsing_or_and
char		**parsing_or_and(t_info_shell *shell, int *loop)
{
  int		i;
  int		j;
  char		**mem;
  char		**tmp;

  (1 == 1) ? (i = -1, j = -1) : 1;
  if (((mem = malloc(sizeof(char *) * my_tablen(shell->tab))) == NULL)
      || ((tmp = malloc(sizeof(char *) * my_tablen(shell->tab))) == NULL))
    return (NULL);
  while ((my_strcmp(shell->tab[++i], "&&") != 0)
         && (my_strcmp(shell->tab[i], "||") != 0))
    {
      if (shell->tab[i] == NULL)
	{
          *loop = 0;
          return (mem);
        }
      tmp[i] = my_strdup(shell->tab[i]);
    }
  tmp[i] = NULL;
  while (shell->tab[i] != NULL)
    mem[++j] = my_strdup(shell->tab[++i]);
  mem[j] = NULL;
  shell->tab = tmp;
  return (mem);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x4788
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2140
testq %rax, %rax
je 0x3642
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x4788
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2140
testq %rax, %rax
je 0x3642
movq %rax, %r15
movq 0x18(%r14), %rax
movq (%rax), %rdi
leaq 0x3cd8(%rip), %rsi      # 0x72b1
callq 0x4752
testl %eax, %eax
je 0x3649
movq %r12, (%rsp)
xorl %r12d, %r12d
leaq 0x3cc4(%rip), %r13      # 0x72b4
leaq 0x3cba(%rip), %rbp      # 0x72b1
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r13, %rsi
callq 0x4752
testl %eax, %eax
je 0x363d
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x36c2
callq 0x4d90
movq %rax, (%r15,%r12,8)
movq 0x18(%r14), %rax
movq 0x8(%rax,%r12,8), %rdi
incq %r12
movq %rbp, %rsi
callq 0x4752
testl %eax, %eax
jne 0x35f7
movslq %r12d, %rcx
jmp 0x364e
xorl %ebx, %ebx
jmp 0x36cc
xorl %ecx, %ecx
xorl %r12d, %r12d
movq $0x0, (%r15,%r12,8)
movq 0x18(%r14), %rax
cmpq $0x0, (%rax,%rcx,8)
je 0x36ad
leaq 0x8(,%rcx,8), %r13
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rbp      # imm = 0x100000000
movq %rbx, (%rsp)
addq %rbp, %r12
movq (%rax,%r13), %rdi
callq 0x4d90
movq %rax, (%rbx)
movq 0x18(%r14), %rax
addq $0x8, %rbx
cmpq $0x0, (%rax,%r13)
leaq 0x8(%r13), %r13
jne 0x3681
sarq $0x20, %r12
movq (%rsp), %rbx
jmp 0x36b4
movq $-0x1, %r12
movq $0x0, (%rbx,%r12,8)
movq %r15, 0x18(%r14)
jmp 0x36cc
movq (%rsp), %rax
movl $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/parsing.c
// Function: marck_init
void		marck_init(t_info_shell *shell, int *marck)
{
  int           i;

  i = 0;
  while (shell->tab[i] != NULL)
    {
      if (my_strcmp(shell->tab[i], "&&") == 0)
	{
          *marck = AND;
          break ;
	}
      if (my_strcmp(shell->tab[i], "||") == 0)
	{
          *marck = OR;
          break ;
	}
      i += 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x374c
movq %rsi, %rbx
xorl %r13d, %r13d
leaq 0x3bae(%rip), %r15      # 0x72b1
leaq 0x3baa(%rip), %r12      # 0x72b4
movq %r15, %rsi
callq 0x4752
testl %eax, %eax
je 0x373e
movq 0x18(%r14), %rax
movq (%rax,%r13), %rdi
movq %r12, %rsi
callq 0x4752
testl %eax, %eax
je 0x3745
movq 0x18(%r14), %rax
movq 0x8(%rax,%r13), %rdi
addq $0x8, %r13
testq %rdi, %rdi
jne 0x370a
jmp 0x374c
movl $0x1, %eax
jmp 0x374a
movl $0x2, %eax
movl %eax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/execution/parsing.c
// Function: parsing
int		parsing(t_info_shell *shell)
{
  char		**save;
  int		marck;
  int		loop;

  if (my_tablen(shell->tab) != 0)
    {
      marck = -1;
      loop = -1;
      while (loop != 0)
	{
	  marck_init(shell, &marck);
	  if (((save = parsing_or_and(shell, &loop)) == NULL)
	      || ((find_flags(shell)) == 84))
	    return (84);
	  if ((shell->flags_value == 0) && (shell->tab[0] != NULL))
	    execute_command(shell);
	  if (detect_or_and(shell, marck) == 1)
	    break ;
	  shell->tab = save;
	  shell->flags_value = 0;
	}
    }
  return (shell->exit_value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x4788
testl %eax, %eax
je 0x3826
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
leaq 0x8(%rsp), %r15
movl %eax, (%r15)
movl $0x54, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36de
movq %rbx, %rdi
movq %r15, %rsi
callq 0x357c
testq %rax, %rax
je 0x3829
movq %rax, %r12
movq %rbx, %rdi
callq 0x34fc
cmpl $0x54, %eax
je 0x3829
cmpl $0x0, 0x40(%rbx)
jne 0x37f8
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax)
je 0x37f8
movq %rbx, %rdi
callq 0x30bf
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
je 0x380e
cmpl $0x1, %eax
jne 0x3814
cmpl $0x1, 0x3c(%rbx)
jne 0x3814
jmp 0x3826
cmpl $0x0, 0x3c(%rbx)
je 0x3826
movq %r12, 0x18(%rbx)
movl $0x0, 0x40(%rbx)
cmpl $0x0, 0x8(%rsp)
jne 0x37b5
movl 0x3c(%rbx), %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/right_redi.c
// Function: cut_tab
char		**cut_tab(char **tab, char *sep)
{
  int		i;
  int		j;
  char		**new_tab;

  i = 0;
  j = 0;
  if ((new_tab = malloc(sizeof(char *) * my_tablen(tab) + 1)) == NULL)
    return (NULL);
  while (tab[i] != NULL)
    {
      if (my_strcmp(tab[i], sep) == 0)
	i += 2;
      if (tab[i] == NULL)
	break ;
      new_tab[j] = my_strdup(tab[i]);
      i += 1;
      j += 1;
    }
  new_tab[j] = NULL;
  free_all(NULL, tab);
  return (new_tab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4788
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x2140
movq %rax, %r14
testq %rax, %rax
je 0x38be
movq (%rbx), %rdi
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x38ac
xorl %r12d, %r12d
movq %r15, %rsi
callq 0x4752
testl %eax, %eax
jne 0x3883
addl $0x2, %r13d
movslq %r13d, %rbp
movq (%rbx,%rbp,8), %rdi
testq %rdi, %rdi
je 0x38a9
callq 0x4d90
movq %rax, (%r14,%r12,8)
leal 0x1(%rbp), %r13d
incq %r12
movq 0x8(%rbx,%rbp,8), %rdi
testq %rdi, %rdi
jne 0x3873
movl %r12d, %r13d
movq $0x0, (%r14,%r13,8)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4715
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/right_redi.c
// Function: right_redi
int		right_redi(char *file_name, t_info_shell *shell)
{
  int		fd;
  pid_t		pid;
  int		statues;

  if ((pid = fork()) == -1)
    return (84);
  else if (pid == 0)
    {
      fd = open(file_name, O_CREAT | O_RDWR | O_TRUNC, 0644);
      dup2(fd, STANDARD_OUTPUT);
      execution_in_chain(shell);
      close(fd);
      exit(0);
    }
  else
    wait(&statues);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x54, %ebp
callq 0x21f0
cmpl $-0x1, %eax
je 0x38fd
testl %eax, %eax
je 0x3908
leaq 0xc(%rsp), %rdi
callq 0x21e0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2160
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x330c
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/right_redi.c
// Function: right_chevron
int		right_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], ">") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, ">")) == NULL)
      || ((right_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x395f(%rip), %r14      # 0x72ba
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x395b
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x39c0
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3922(%rip), %rsi      # 0x72ba
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x39c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38d0
cmpl $0x54, %eax
je 0x39c0
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/left_redi.c
// Function: left_redi
int		left_redi(char *file_name, t_info_shell *shell)
{
  int		fd;
  pid_t		pid;
  int		status;

  if ((pid = fork()) == -1)
    return (84);
  else if (pid == 0)
    {
      if ((fd = open(file_name, O_RDONLY)) == -1)
	{
	  my_printf("%s:%s", file_name, NO_SUCH_FILE);
	  exit(84);
	}
      dup2(fd, 0);
      execution_in_chain(shell);
      close(fd);
      exit(0);
    }
  else
    wait(&status);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x54, %ebp
callq 0x21f0
cmpl $-0x1, %eax
je 0x39fd
testl %eax, %eax
je 0x3a08
leaq 0xc(%rsp), %rdi
callq 0x21e0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2160
cmpl $-0x1, %eax
jne 0x3a3b
leaq 0x38a5(%rip), %rdi      # 0x72c5
leaq 0x3647(%rip), %rdx      # 0x706e
movq %r14, %rsi
xorl %eax, %eax
callq 0x5bb6
movl $0x54, %edi
callq 0x21b0
movl %eax, %ebp
movl %eax, %edi
xorl %esi, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x330c
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/left_redi.c
// Function: left_chevron
int		left_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], "<") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, "<")) == NULL)
      || ((left_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x3840(%rip), %r14      # 0x72b7
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x3a77
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x3adc
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3803(%rip), %rsi      # 0x72b7
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3adc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39d0
cmpl $0x54, %eax
je 0x3adc
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/pipes.c
// Function: cut_pipe
char		**cut_pipe(char **tab, char  ***new_tab)
{
  int		i;
  int		j;
  int		marker;
  char		**tmp;

  i = 0;
  j = 0;
  if ((tmp = malloc(sizeof(char *) * (my_tablen(tab) + 1))) == NULL)
    return (NULL);
  while (my_strcmp(tab[i], "|") != 0)
    i += 1;
  marker = i;
  i += 1;
  while (tab[i] != NULL)
    {
      tmp[j] = my_strdup(tab[i]);
      free(tab[i]);
      i += 1;
      j += 1;
    }
  tab[marker] = NULL;
  tmp[j] = NULL;
  *new_tab = tmp;
  return (tab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4788
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2140
testq %rax, %rax
je 0x3b86
movq %rax, %r15
leaq 0x8(%rbx), %r13
xorl %ebp, %ebp
leaq 0x378f(%rip), %r12      # 0x72b5
movq -0x8(%r13), %rdi
movq %r12, %rsi
callq 0x4752
incq %rbp
addq $0x8, %r13
testl %eax, %eax
jne 0x3b26
movl %ebp, %eax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x3b8a
movq %r14, (%rsp)
leaq (%rbx,%rax,8), %r14
xorl %r12d, %r12d
movq %r13, %rax
movq %rax, %rbp
callq 0x4d90
movq %rax, (%r15,%r12,8)
movq (%r14), %rdi
callq 0x2030
incq %r12
movq (%rbp), %rdi
leaq 0x8(%rbp), %rax
movq %rbp, %r14
testq %rdi, %rdi
jne 0x3b56
movl %r12d, %eax
movq (%rsp), %r14
jmp 0x3b8c
xorl %ebx, %ebx
jmp 0x3b99
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, -0x10(%r13)
movq %rcx, (%r15,%rax,8)
movq %r15, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/pipes.c
// Function: pipe_return_value
void		pipe_return_value(t_info_shell *shell, char **new_tab)
{
  if (shell->exit_value == 1)
    my_printf("%s: %s", shell->tab[0], COMMAND_ERROR);
  shell->tab = new_tab;
  if (((is_valid_command(shell) == NULL)))
    shell->exit_value = 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, 0x3c(%rdi)
jne 0x3bd7
movq 0x18(%rbx), %rax
movq (%rax), %rsi
leaq 0x361b(%rip), %rdi      # 0x71e4
leaq 0x361b(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5bb6
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
callq 0x301a
testq %rax, %rax
jne 0x3bef
movl $0x1, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/pipes.c
// Function: verif_tabs
int		verif_tabs(t_info_shell *shell, char **new_tab)
{
  if ((shell->tab[0] == NULL) || (new_tab[0] == NULL))
    {
      my_printf("Invalid null command.\n");
      shell->exit_value = 1;
      return (-1);
    }
  return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $0x0, (%rax)
je 0x3c0d
xorl %eax, %eax
cmpq $0x0, (%rsi)
jne 0x3c27
leaq 0x36b7(%rip), %rdi      # 0x72cb
xorl %eax, %eax
callq 0x5bb6
movl $0x1, 0x3c(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/pipes.c
// Function: my_pipes
int		my_pipes(t_info_shell *shell,
			 char **new_tab, char **save)
{
  int		pfd[2];
  pid_t		pid;

  if (((pipe(pfd)) == -1) || ((pid = fork()) == -1))
    return (84);
  if (pid == 0)
    {
      close(pfd[FD_ENTRY]);
      dup2(pfd[FD_EXIT], 0);
      close(pfd[FD_EXIT]);
      shell->tab = new_tab;
      parsing(shell);
      exit(shell->exit_value);
    }
  else
    {
      close(pfd[FD_EXIT]);
      dup2(pfd[FD_ENTRY], 1);
      close(pfd[FD_ENTRY]);
      shell->tab = save;
      parsing(shell);
    }
  return (shell->exit_value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x20e0
movl $0x54, %ebp
cmpl $-0x1, %eax
je 0x3c87
callq 0x21f0
cmpl $-0x1, %eax
je 0x3c87
testl %eax, %eax
je 0x3c94
movl (%rsp), %edi
callq 0x20d0
movl 0x4(%rsp), %edi
movl $0x1, %esi
callq 0x20b0
movl 0x4(%rsp), %edi
callq 0x20d0
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
callq 0x377b
movl 0x3c(%rbx), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %edi
callq 0x20d0
movl (%rsp), %edi
xorl %esi, %esi
callq 0x20b0
movl (%rsp), %edi
callq 0x20d0
movq %r15, 0x18(%rbx)
movq %rbx, %rdi
callq 0x377b
movl 0x3c(%rbx), %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/pipes.c
// Function: pipes
int		pipes(t_info_shell *shell)
{
  char		**new_tab;
  char		**save;
  int		status;
  pid_t		pid;

  new_tab = NULL;
  if ((shell->tab = cut_pipe(shell->tab, &new_tab)) == NULL)
    return (84);
  save = shell->tab;
  shell->flags_value = 1;
  if ((verif_tabs(shell, new_tab)) == -1)
    return (-1);
  if ((pid = fork()) == -1)
    return (84);
  else if (pid == 0)
    exit(my_pipes(shell, new_tab, save));
  else
    {
      waitpid(pid, &status, WUNTRACED);
      shell->exit_value = WEXITSTATUS(status);
      pipe_return_value(shell, new_tab);
    }
  free_all(NULL, new_tab);
  free_all(NULL, save);
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq 0x18(%rdi), %rdi
callq 0x3aec
movq %rax, 0x18(%rbx)
movl $0x54, %r15d
testq %rax, %rax
je 0x3d7e
movq %rax, %r14
movl $0x1, 0x40(%rbx)
cmpq $0x0, (%rax)
je 0x3d63
movq 0x8(%rsp), %r12
cmpq $0x0, (%r12)
je 0x3d63
callq 0x21f0
cmpl $-0x1, %eax
je 0x3d7e
testl %eax, %eax
je 0x3d8d
leaq 0x14(%rsp), %r15
movl %eax, %edi
movq %r15, %rsi
movl $0x2, %edx
callq 0x2150
movzbl 0x1(%r15), %eax
movl %eax, 0x3c(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3bab
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4715
xorl %edi, %edi
movq %r14, %rsi
callq 0x4715
jmp 0x3d7e
leaq 0x3561(%rip), %rdi      # 0x72cb
xorl %eax, %eax
callq 0x5bb6
movl $0x1, 0x3c(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c29
movl %eax, %edi
callq 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/double_right_redi.c
// Function: double_right_redi
int		double_right_redi(char *file_name, t_info_shell *shell)
{
  int		fd;
  pid_t		pid;
  int		statues;

  if ((pid = fork()) == -1)
    return (84);
  else if (pid == 0)
    {
      if ((fd = open(file_name, O_RDWR | O_APPEND, 0644)) == -1)
	fd = open(file_name, O_RDWR | O_CREAT, 0644);
      dup2(fd, STANDARD_OUTPUT);
      execute_command(shell);
      close(fd);
      exit(shell->exit_value);
    }
  else
    {
      wait(&statues);
      shell->exit_value = WEXITSTATUS(statues);
    }
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x54, %ebp
callq 0x21f0
cmpl $-0x1, %eax
je 0x3ddc
testl %eax, %eax
je 0x3de7
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x21e0
movzbl 0x1(%r14), %eax
movl %eax, 0x3c(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movl $0x402, %esi            # imm = 0x402
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2160
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x3e18
movq %r14, %rdi
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2160
movl %eax, %ebp
movl %ebp, %edi
movl $0x1, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x30bf
movl %ebp, %edi
callq 0x20d0
movl 0x3c(%rbx), %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/double_right_redi.c
// Function: double_right_chevron
int		double_right_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], ">>") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, ">>")) == NULL)
      || ((double_right_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x3467(%rip), %r14      # 0x72bd
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x3e56
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x3ebb
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x342a(%rip), %rsi      # 0x72bd
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3ebb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3da4
cmpl $0x54, %eax
je 0x3ebb
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/double_right_redi.c
// Function: double_error_chevron
int		double_error_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], "2>>") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, "2>>")) == NULL)
      || ((double_error_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x334e(%rip), %r14      # 0x72bc
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x3f6e
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x3fd3
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3311(%rip), %rsi      # 0x72bc
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3fd3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ec8
cmpl $0x54, %eax
je 0x3fd3
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/and.c
// Function: copy_my_tab
char		**copy_my_tab(char **tab)
{
  int		i;
  char		**new;

  i = 0;
  if ((new = malloc(sizeof(char *) * (my_tablen(tab) + 1))) == NULL)
    return (NULL);
  while (tab[i] != NULL)
    {
      new[i] = my_strdup(tab[i]);
      i += 1;
    }
  new[i] = NULL;
  return (new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4788
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2140
movq %rax, %r14
testq %rax, %rax
je 0x402a
movq (%rbx), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x4022
callq 0x4d90
movq %rax, (%r14,%r15,8)
movq 0x8(%rbx,%r15,8), %rdi
incq %r15
jmp 0x400a
movq $0x0, (%r14,%r15,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/and.c
// Function: reverse_tab
char		**reverse_tab(char **tab)
{
  int		i;
  int		j;
  char		*tmp;

  i = 0;
  j = 0;
  while (tab[j] != NULL)
    j += 1;
  j -= 1;
  while (i <= j)
    {
      tmp = my_strdup(tab[i]);
      tab[i] = my_strdup(tab[j]);
      tab[j] = my_strdup(tmp);
      i += 1;
      j -= 1;
    }
  free(tmp);
  return (tab);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0x2, %r15
cmpq $0x0, 0x10(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x4045
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x4d90
movq %rax, %r14
movq (%rbx,%r15,8), %rdi
callq 0x4d90
movq %rax, (%rbx,%r12,8)
movq %r14, %rdi
callq 0x4d90
movq %rax, (%rbx,%r15,8)
incq %r12
leaq -0x1(%r15), %rax
cmpq %r15, %r12
movq %rax, %r15
jl 0x4054
movq %r14, %rdi
callq 0x2030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/and.c
// Function: and
int		and(t_info_shell *shell)
{
  char		**mem;
  int		mark;

  mark = 0;
  shell->flags_value = 1;
  mem = copy_my_tab(shell->tab);
  while (1)
    {
      if (my_tablen(shell->tab) != 1)
	shell->tab = cut(shell->tab, &mem);
      execute_command(shell);
      if ((shell->exit_value == 1) || (mark == 1))
	break ;
      shell->tab = mem;
      if (my_tablen(mem) == 1)
	mark = 1;
    }
  free_all(NULL, mem);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
movq 0x18(%rdi), %rdi
callq 0x3fe0
movq %rax, %r14
addq $-0x10, %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
leaq 0x31dd(%rip), %r15      # 0x72b1
movq %rbx, 0x8(%rsp)
movq 0x18(%rbx), %rdi
callq 0x4788
cmpl $0x1, %eax
je 0x420b
movq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x4788
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2140
movq %rax, %r12
testq %rax, %rax
je 0x4207
movq (%r13), %rdi
movq %r15, %rsi
callq 0x4752
xorl %ebx, %ebx
testl %eax, %eax
je 0x4144
movq (%r13,%rbx,8), %rdi
callq 0x4d90
movq %rax, (%r12,%rbx,8)
movq 0x8(%r13,%rbx,8), %rdi
incq %rbx
movq %r15, %rsi
callq 0x4752
jmp 0x4120
movq %rbp, 0x10(%rsp)
movq $0x0, (%r12,%rbx,8)
movq %r14, %rdi
callq 0x4033
movq $-0x2, %rcx
movl $0x2, %edx
movq (%rsp), %rax
movq %rdx, %r13
cmpq $0x0, 0x10(%r14,%rcx,8)
movq %rax, %rbp
leaq 0x1(%rcx), %rcx
leaq -0x1(%rdx), %rdx
leaq 0x8(%rax), %rax
jne 0x4169
movslq %ecx, %r15
leaq (%r14,%r15,8), %rbx
movq (%r14,%r15,8), %rdi
leaq 0x311c(%rip), %rsi      # 0x72b1
callq 0x4752
testl %r15d, %r15d
je 0x41da
testl %eax, %eax
je 0x41da
leaq 0x3107(%rip), %r15      # 0x72b1
movq (%rbx), %rdi
movq %rbp, %rbx
callq 0x2030
movq (%rbp), %rdi
movq %r15, %rsi
callq 0x4752
addq $-0x8, %rbp
testq %r13, %r13
je 0x41d1
incq %r13
testl %eax, %eax
jne 0x41aa
addq $0x8, %rbp
movq %rbp, %rbx
jmp 0x41e1
leaq 0x30d0(%rip), %r15      # 0x72b1
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x4788
cmpl $0x1, %eax
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %rbp
je 0x4207
movq %r14, %rdi
callq 0x4033
movq %r12, 0x18(%rbx)
movq %rbx, %rdi
callq 0x30bf
cmpl $0x1, 0x3c(%rbx)
sete %al
orb %al, %bpl
testb $0x1, %bpl
jne 0x423b
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x4788
cmpl $0x1, %eax
sete %bpl
jmp 0x40d9
xorl %edi, %edi
movq %r14, %rsi
callq 0x4715
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/or.c
// Function: or
int		or(t_info_shell *shell)
{
  char		**mem;
  int		mark;

  mark = 0;
  shell->flags_value = 1;
  mem = copy_my_tab(shell->tab);
  while (1)
    {
      if (my_tablen(shell->tab) != 1)
	shell->tab = cut(shell->tab, &mem);
      execute_command(shell);
      if ((shell->exit_value == 0) || (mark == 1))
	break ;
      shell->tab = mem;
      if (my_tablen(mem) == 1)
	mark = 1;
    }
  free_all(NULL, mem);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
movq 0x18(%rdi), %rdi
callq 0x3fe0
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x302f(%rip), %r15      # 0x72b4
movq %rbx, 0x8(%rsp)
movq 0x18(%rbx), %rdi
callq 0x4788
cmpl $0x1, %eax
je 0x43c2
movq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x4788
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2140
movq %rax, %r12
testq %rax, %rax
je 0x43be
movq (%r13), %rdi
movq %r15, %rsi
callq 0x4752
xorl %ebx, %ebx
testl %eax, %eax
je 0x42f5
movq (%r13,%rbx,8), %rdi
callq 0x4d90
movq %rax, (%r12,%rbx,8)
movq 0x8(%r13,%rbx,8), %rdi
incq %rbx
movq %r15, %rsi
callq 0x4752
jmp 0x42d1
movq %rbp, 0x10(%rsp)
movq $0x0, (%r12,%rbx,8)
movq %r14, %rdi
callq 0x4033
movq %rax, %r14
addq $-0x10, %rax
movq $-0x2, %rcx
movl $0x2, %edx
movq %rdx, %r13
cmpq $0x0, 0x10(%r14,%rcx,8)
movq %rax, %rbp
leaq 0x1(%rcx), %rcx
leaq -0x1(%rdx), %rdx
leaq 0x8(%rax), %rax
jne 0x431d
movslq %ecx, %r15
leaq (%r14,%r15,8), %rbx
movq (%r14,%r15,8), %rdi
leaq 0x2f6b(%rip), %rsi      # 0x72b4
callq 0x4752
testl %r15d, %r15d
je 0x438e
testl %eax, %eax
je 0x438e
leaq 0x2f56(%rip), %r15      # 0x72b4
movq (%rbx), %rdi
movq %rbp, %rbx
callq 0x2030
movq (%rbp), %rdi
movq %r15, %rsi
callq 0x4752
addq $-0x8, %rbp
testq %r13, %r13
je 0x4385
incq %r13
testl %eax, %eax
jne 0x435e
addq $0x8, %rbp
movq %rbp, %rbx
jmp 0x4395
leaq 0x2f1f(%rip), %r15      # 0x72b4
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x4788
cmpl $0x1, %eax
movq 0x10(%rsp), %rbp
je 0x43b9
movq %r14, %rdi
callq 0x4033
movq %rax, %r14
movq 0x8(%rsp), %rbx
movq %r12, 0x18(%rbx)
movq %rbx, %rdi
callq 0x30bf
cmpl $0x0, 0x3c(%rbx)
sete %al
orb %al, %bpl
testb $0x1, %bpl
jne 0x43f2
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x4788
cmpl $0x1, %eax
sete %bpl
jmp 0x428a
xorl %edi, %edi
movq %r14, %rsi
callq 0x4715
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/redi_all.c
// Function: all_chevron
int		all_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], "2>&1") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, "2>&1")) == NULL)
      || ((all_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x2e19(%rip), %r14      # 0x72c0
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x44a7
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x450c
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x2ddc(%rip), %rsi      # 0x72c0
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x450c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4410
cmpl $0x54, %eax
je 0x450c
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/redi_all.c
// Function: error_redi
int		error_redi(char *file_name, t_info_shell *shell)
{
  int		fd;
  pid_t		pid;
  int		statues;

  if ((pid = fork()) == -1)
    return (84);
  else if (pid == 0)
    {
      fd = open(file_name, O_CREAT | O_RDWR | O_TRUNC, 0644);
      dup2(fd, 2);
      execution_in_chain(shell);
      close(fd);
      exit(0);
    }
  else
    wait(&statues);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x54, %ebp
callq 0x21f0
cmpl $-0x1, %eax
je 0x4546
testl %eax, %eax
je 0x4551
leaq 0xc(%rsp), %rdi
callq 0x21e0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2160
movl %eax, %ebp
movl %eax, %edi
movl $0x2, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x330c
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/flags/redi_all.c
// Function: error_chevron
int		error_chevron(t_info_shell *shell)
{
  int		i;
  char		*file_name;

  i = 0;
  shell->flags_value = 1;
  while (my_strcmp(shell->tab[i], "2>") != 0)
    i += 1;
  if (((file_name = my_strdup(shell->tab[i + 1])) == NULL)
      || ((shell->tab = cut_tab(shell->tab, "2>")) == NULL)
      || ((error_redi(file_name, shell)) == 84))
    return (84);
  free(file_name);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
xorl %r15d, %r15d
leaq 0x2d15(%rip), %r14      # 0x72b9
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x4752
addq $0x8, %r15
testl %eax, %eax
jne 0x45a4
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4d90
movl $0x54, %ebp
testq %rax, %rax
je 0x4609
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x2cd8(%rip), %rsi      # 0x72b9
callq 0x3838
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x4609
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4519
cmpl $0x54, %eax
je 0x4609
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/historic/history.c
// Function: history_add
char	**history_add(char **old_h, char *line)
{
  char	**new_h;
  int	i;

  if ((new_h = malloc(sizeof(char *) * (my_tablen(old_h) + 2))) == NULL)
    return (NULL);
  new_h[0] = my_strdup(line);
  i = 0;
  while (old_h[i] != NULL)
    {
      new_h[i + 1] = old_h[i];
      i += 1;
    }
  new_h[i + 1] = NULL;
  if (*old_h != NULL)
    free(old_h);
  return (new_h);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4788
cltq
leaq 0x10(,%rax,8), %rdi
callq 0x2140
movq %rax, %r14
testq %rax, %rax
je 0x468a
movq %r15, %rdi
callq 0x4d90
movq %rax, (%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0x4682
movl $0x8, %ecx
movq %rax, %rdx
movq %rdx, (%r14,%rcx)
movq (%rbx,%rcx), %rdx
addq $0x8, %rcx
testq %rdx, %rdx
jne 0x465a
movq $0x0, (%r14,%rcx)
testq %rax, %rax
je 0x468a
movq %rbx, %rdi
callq 0x2030
jmp 0x468a
movq $0x0, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/historic/history.c
// Function: print_historic
int	print_historic(t_info_shell *shell)
{
  shell->historic = reverse_tab(shell->historic);
  my_printf("%t", shell->historic);
  shell->historic = reverse_tab(shell->historic);
  return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x4033
movq %rax, 0x28(%rbx)
leaq 0x2975(%rip), %rdi      # 0x7020
movq %rax, %rsi
xorl %eax, %eax
callq 0x5bb6
movq 0x28(%rbx), %rdi
callq 0x4033
movq %rax, 0x28(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/find_str.c
// Function: my_find_str
int	my_find_str(char *str, char *to_find)
{
  int	i;
  char	*ptr_one;
  char	*ptr_two;

  i = 0;
  while (str[i++] != '\0')
    {
      ptr_one = str;
      ptr_two = to_find;
      while (*ptr_one == *ptr_two)
	{
	  ptr_one++;
	  ptr_two++;
	  if (*ptr_two == 0)
	    return (1);
	}
    }
  return (0);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x46f8
movb (%rsi), %al
movl $0x1, %ecx
xorl %edx, %edx
movl %eax, %r8d
cmpb %r8b, (%rdi,%rdx)
jne 0x46ee
movb 0x1(%rsi,%rdx), %r8b
incq %rdx
testb %r8b, %r8b
jne 0x46d9
jmp 0x46fb
cmpb $0x0, (%rdi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x46d4
xorl %eax, %eax
retq
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/function.c
// Function: free_all
void		free_all(char *str, char **tab)
{
  int		i;

  i = 0;
  while (tab[i] != NULL)
    {
      free(tab[i]);
      i += 1;
    }
  free(tab);
  free(str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x473d
leaq 0x8(%r14), %r15
callq 0x2030
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x472c
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/function.c
// Function: my_strcmp
int		my_strcmp(char *s1, char *s2)
{
  int		i;

  i = 0;
  if (s1 == NULL || s2 == NULL)
    return (1);
  while ((s1[i] != '\0' && s2[i] != '\0' && s1[i] == s2[i]))
    i += 1;
  if (s1[i] != s2[i])
    return (1);
  return (0);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x1, %eax
jne 0x4787
movb (%rdi), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x477d
cmpb (%rsi,%rcx), %dl
jne 0x477f
movb 0x1(%rdi,%rcx), %dl
incq %rcx
jmp 0x476b
xorl %edx, %edx
xorl %eax, %eax
cmpb (%rsi,%rcx), %dl
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/function_two.c
// Function: my_count
int		my_count(char *str, char sep)
{
  int		i;
  int		j;

  i = 0;
  j = 0;
  while (str[i] != '\0')
    {
      if (str[i] == sep)
	j += 1;
      i += 1;
    }
  j = j * 2;
  return (j);
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x47c1
incq %rdi
xorl %eax, %eax
xorl %edx, %edx
cmpb %sil, %cl
sete %dl
addl %edx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x47ab
addl %eax, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/function_two.c
// Function: init_struct
void		init_struct(t_info_shell *shell)
{
  shell->exit_value = 0;
  shell->alias_value = 0;
  if ((shell->historic = malloc(sizeof(char *) * 1)) == NULL)
    return ;
  shell->historic[0] = NULL;
  shell->path_save = get_path(environ, "PATH");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x3c(%rdi)
movl %eax, 0x44(%rdi)
movl $0x8, %edi
callq 0x2140
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x4819
movq $0x0, (%rax)
movq 0x67e2(%rip), %rax      # 0xafe8
movq (%rax), %rdi
leaq 0x2923(%rip), %rsi      # 0x7133
callq 0x49ce
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/function_two.c
// Function: free_struct
void		free_struct(t_info_shell *shell)
{
  free_all(shell->command, shell->tab);
  free_all(shell->mem, shell->tab_mem);
  free_all(shell->path_save, shell->historic);
  free_all(NULL, shell->alias_tab);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rbx), %rsi
callq 0x4715
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x4715
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x4715
movq 0x30(%rbx), %rsi
xorl %edi, %edi
popq %rbx
jmp 0x4715
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/my_epurstr.c
// Function: my_epurstr
char	*my_epurstr(char *str)
{
  int	i;
  int	x;
  char	*str2;

  i = 0;
  x = 0;
  if ((str == NULL)
      || ((str2 = malloc(sizeof(char) * my_strlen(str) + 1)) == NULL))
    return (NULL);
  while (str[i] != '\0')
    {
      while (((str[i] == ' ' || str[i] == '\t') &&
	      (str[i + 1] == ' ' || str[i + 1] == '\t')))
	i++;
      if (str[i] == '\t')
	str[i] = ' ';
      str2[x++] = str[i++];
    }
  str2[x] = '\0';
  if (str2[x - 1] == ' ' || str2[x - 1] == '\t')
    str2[x - 1] = '\0';
  if ((*str2 == ' ' || *str2 == '\t'))
    str2++;
  free(str);
  return (str2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4929
movq %rdi, %rbx
callq 0x4704
movslq %eax, %rdi
incq %rdi
callq 0x2140
testq %rax, %rax
je 0x4929
movq %rax, %r14
movb (%rbx), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x48f3
xorl %ecx, %ecx
movslq %eax, %rsi
leal 0x1(%rsi), %eax
addq %rbx, %rsi
cmpb $0x20, %dl
je 0x48bf
movzbl %dl, %edi
cmpl $0x9, %edi
jne 0x48de
movzbl 0x1(%rsi), %edi
cmpl $0x20, %edi
je 0x48cd
cmpl $0x9, %edi
jne 0x48d6
incl %eax
incq %rsi
movl %edi, %edx
jmp 0x48b2
cmpb $0x9, %dl
jne 0x48de
movb $0x20, (%rsi)
movb (%rsi), %dl
movb %dl, (%r14,%rcx)
incq %rcx
movslq %eax, %rdx
movb (%rbx,%rdx), %dl
testb %dl, %dl
jne 0x48a9
movl %ecx, %eax
movb $0x0, (%r14,%rax)
movzbl -0x1(%r14,%rax), %ecx
cmpl $0x20, %ecx
je 0x4908
cmpl $0x9, %ecx
jne 0x490e
movb $0x0, -0x1(%r14,%rax)
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0x491c
cmpl $0x9, %eax
jne 0x491f
incq %r14
movq %rbx, %rdi
callq 0x2030
jmp 0x492c
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/my_path.c
// Function: search_path
int		search_path(char **my_env, char *key)
{
  t_count	ct;
  char		*mem;

  ct.i = 0;
  while (my_env[ct.i] != NULL)
    {
      ct.j = 0;
      ct.k = 0;
      if ((mem = malloc(sizeof(char) * my_strlen(my_env[ct.i]))) == NULL)
	return (84);
      while (my_env[ct.i][ct.j] != '=')
	{
	  mem[ct.k++] = my_env[ct.i][ct.j++];
	}
      mem[ct.k] = '\0';
      if (my_strcmp(mem, key) == 0)
	{
	  free(mem);
	  return (ct.i);
	}
      free(mem);
      ct.i += 1;
    }
  return (84);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movl $0x54, %ebx
testq %rdi, %rdi
je 0x49c2
movq %rsi, %r14
xorl %r13d, %r13d
callq 0x4704
movslq %eax, %rdi
callq 0x2140
testq %rax, %rax
je 0x49c2
movq %rax, %r12
movq (%r15,%r13,8), %rax
movb (%rax), %cl
cmpb $0x3d, %cl
jne 0x497b
xorl %eax, %eax
jmp 0x498f
xorl %edx, %edx
movb %cl, (%r12,%rdx)
movb 0x1(%rax,%rdx), %cl
incq %rdx
cmpb $0x3d, %cl
jne 0x497d
movl %edx, %eax
movb $0x0, (%r12,%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x4752
movq %r12, %rdi
testl %eax, %eax
je 0x49ba
callq 0x2030
movq 0x8(%r15,%r13,8), %rdi
incq %r13
testq %rdi, %rdi
jne 0x4957
jmp 0x49c2
callq 0x2030
movl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/my_path.c
// Function: get_path
char		*get_path(char **my_env, char *key)
{
  int		i;
  int		j;
  int		k;
  char		*tmp;

  i = search_path(my_env, key);
  if (i == 84)
    return (NULL);
  j = 0;
  k = 0;
  if ((tmp = malloc(sizeof(char) * my_strlen(my_env[i] + 1))) == NULL)
    return (NULL);
  while (my_env[i][j - 1] != '=')
    j += 1;
  while (my_env[i][j] != '\0')
    {
      tmp[k++] = my_env[i][j++];
    }
  tmp[k] = '\0';
  return (tmp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4938
cmpl $0x54, %eax
je 0x4a38
movslq %eax, %r14
movq (%rbx,%r14,8), %rdi
incq %rdi
callq 0x4704
movslq %eax, %rdi
callq 0x2140
testq %rax, %rax
je 0x4a38
movq (%rbx,%r14,8), %rcx
movq $-0x1, %rdx
cmpb $0x3d, (%rcx,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x4a06
movl %edx, %esi
movb (%rcx,%rsi), %dil
testb %dil, %dil
je 0x4a3c
xorl %esi, %esi
movq %rsi, %r8
incq %rsi
movb %dil, (%rax,%r8)
addq %rcx, %r8
movb 0x1(%rdx,%r8), %dil
testb %dil, %dil
jne 0x4a1d
movl %esi, %ecx
jmp 0x4a3e
xorl %eax, %eax
jmp 0x4a42
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/get_next_line.c
// Function: get_next_line
char		*get_next_line(const int fd)
{
  static int	size = 1;
  static char	*mem = NULL;
  char		buff[READ_SIZE + 1];
  char		*line;

  line = NULL;
  while (size != 0 && my_str_contain(line, '\n') == -1)
    {
      if ((size = read(fd, buff, READ_SIZE)) == -1)
	return (NULL);
      buff[size] = '\0';
      if ((line = my_strcat(line, buff, 1)) == NULL)
	return (NULL);
    }
  if ((line = get_line(line, &mem)) == NULL)
    return (NULL);
  if (my_strlen(line) == 0 && size == 0)
    return (NULL);
  return (line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
xorl %r14d, %r14d
leaq 0x6(%rsp), %r15
xorl %ebx, %ebx
cmpl $0x0, 0x66aa(%rip)      # 0xb110
je 0x4ac8
testq %rbx, %rbx
je 0x4a86
xorl %eax, %eax
movzbl (%rbx,%rax), %ecx
testl %ecx, %ecx
je 0x4a86
cmpl $0xa, %ecx
je 0x4a81
incq %rax
jmp 0x4a6f
cmpl $-0x1, %eax
jne 0x4ac8
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2100
movl %eax, 0x6675(%rip)      # 0xb110
cmpl $-0x1, %eax
je 0x4b88
cltq
movb $0x0, 0x6(%rsp,%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x4f08
movq %rax, %rbx
testq %rax, %rax
jne 0x4a5f
jmp 0x4b88
cmpb $0x0, (%rbx)
je 0x4b20
movq 0x6734(%rip), %rdi      # 0xb208
testq %rdi, %rdi
je 0x4afd
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4f08
testq %rax, %rax
je 0x4b88
movq %rax, %rbx
movq $0x0, 0x670b(%rip) # 0xb208
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rbx, %rdx
movzbl (%rdx), %esi
testl %esi, %esi
je 0x4b2b
cmpl $0xa, %esi
je 0x4b25
addq %rcx, %rax
incq %rdx
jmp 0x4b0c
xorl %r14d, %r14d
jmp 0x4b88
sarq $0x20, %rax
jmp 0x4b32
movq $-0x1, %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rdi
callq 0x4704
cltq
leaq (%rbx,%rax), %r15
incq %r15
movq %r15, %rdi
callq 0x4704
xorl %r14d, %r14d
testl %eax, %eax
cmoveq %r14, %r15
xorl %edi, %edi
movq %r15, %rsi
movl $0x2, %edx
callq 0x4f08
movq %rax, 0x669a(%rip)      # 0xb208
testq %rax, %rax
je 0x4b88
movq %rbx, %rdi
callq 0x4704
xorl %r14d, %r14d
orl 0x658c(%rip), %eax      # 0xb110
cmovneq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MaxenceEpitech[P]42sh/src/my_str_to_wordtab.c
// Function: count_words
int		count_words(const char *str, char sep)
{
  int		words;
  int		i;

  i = 0;
  words = 1;
  while (str[0] == sep)
    str = str + 1;
  while (str[i] != '\0')
    {
      if (str[i] == sep)
	{
	  while (str[i] == sep)
	    i = i + 1;
	  words = words + 1;
	}
      if (str[i] != '\0')
	i = i + 1;
    }
  if (i != 0 && str[i - 1] == sep)
    words = words - 1;
  return (words);
}

// Assembly:
decq %rdi
movb 0x1(%rdi), %dl
incq %rdi
cmpb %sil, %dl
je 0x4b9b
movl $0x1, %eax
testb %dl, %dl
je 0x4bff
xorl %ecx, %ecx
cmpb %sil, %dl
jne 0x4bcf
movslq %ecx, %rdx
leal -0x1(%rdx), %ecx
addq %rdi, %rdx
incl %ecx
leaq 0x1(%rdx), %r8
cmpb %sil, (%rdx)
movq %r8, %rdx
je 0x4bbf
incl %eax
movslq %ecx, %rdx
xorl %r8d, %r8d
cmpb $0x0, (%rdi,%rdx)
setne %r8b
leal (%rdx,%r8), %ecx
addq %rdx, %r8
movb (%rdi,%r8), %dl
testb %dl, %dl
jne 0x4bb1
testl %ecx, %ecx
je 0x4bff
movslq %ecx, %rcx
xorl %edx, %edx
cmpb %sil, -0x1(%rcx,%rdi)
sete %dl
subl %edx, %eax
retq