LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/alias.c
// Function: recognize_my_alias
int		recognize_my_alias(char **commands,
				   char **alias, t_info_shell *shell)
{
  int		i;
  int		j;
  int		size;

  i = -1;
  size = (my_tablen(shell->tab) + my_tablen(commands)) + 1;
  while (shell->tab[++i] != NULL)
    {
      j = -1;
      while (alias[++j] != NULL)
	{
	  if ((my_strcmp(shell->tab[i], alias[j])) == 0)
	    {
	      if (my_tablen(shell->tab) != 1)
		shell->tab = create_new_command(commands, alias, shell, size);
	      else
		{
		  free_all(NULL, shell->tab);
		  shell->tab = my_str_to_wordtab(commands[j], ' ');
		}
	      return (0);
	    }
	}
    }
  return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdx), %rdi
callq 0x47c2
movl %eax, %r12d
movq %r14, %rdi
callq 0x47c2
movq 0x18(%rbx), %rcx
movl $0x1, %ebp
cmpq $0x0, (%rcx)
je 0x28ab
addl %r12d, %eax
incl %eax
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15,%r13), %rsi
movq 0x18(%rbx), %rax
testq %rsi, %rsi
je 0x285a
movq (%rax,%r12,8), %rdi
callq 0x478e
addq $0x8, %r13
testl %eax, %eax
jne 0x283a
jmp 0x2869
cmpq $0x0, 0x8(%rax,%r12,8)
leaq 0x1(%r12), %r12
jne 0x2837
jmp 0x28ab
movq 0x18(%rbx), %rdi
callq 0x47c2
cmpl $0x1, %eax
jne 0x2893
movq 0x18(%rbx), %rsi
xorl %edi, %edi
callq 0x4751
movq -0x8(%r14,%r13), %rdi
movl $0x20, %esi
callq 0x4cfb
jmp 0x28a5
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl 0x4(%rsp), %ecx
callq 0x268f
movq %rax, 0x18(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/alias_detection.c
// Function: create_my_alias
int		create_my_alias(t_info_shell *shell)
{
  char		*new_alias;

  if (alias_check(shell) == 0)
    {
      new_alias = create_valid_alias(shell->tab);
      if (shell->alias_value == 0)
	shell->alias_tab = add_new_alias(shell->alias_tab, new_alias);
      shell->alias_value = 0;
    }
  return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2a08
testl %eax, %eax
jne 0x28ef
movq 0x18(%rbx), %rdi
callq 0x2aa0
cmpl $0x0, 0x44(%rbx)
jne 0x28e8
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x2b3e
movq %rax, 0x30(%rbx)
movl $0x0, 0x44(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/alias_detection.c
// Function: replace_existing_alias
int		replace_existing_alias(char *new_alias, t_info_shell *shell)
{
  char		**alias;
  int		i;

  i = 0;
  alias = cut_alias(shell->alias_tab);
  while (alias[i] != NULL)
    {
      if (my_strcmp(alias[i], new_alias) == 0)
	{
	  shell->alias_tab[i] = my_strdup(create_valid_alias(shell->tab));
	  shell->alias_value = 1;
	}
      i += 1;
    }
  free_all(NULL, alias);
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rdi
callq 0x24fd
movq %rax, %r15
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2952
xorl %r12d, %r12d
movq %r14, %rsi
callq 0x478e
testl %eax, %eax
jne 0x2944
movq 0x18(%rbx), %rdi
callq 0x2aa0
movq %rax, %rdi
callq 0x4dec
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r12)
movl $0x1, 0x44(%rbx)
movq 0x8(%r15,%r12), %rdi
addq $0x8, %r12
testq %rdi, %rdi
jne 0x2918
xorl %edi, %edi
movq %r15, %rsi
callq 0x4751
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/alias_detection.c
// Function: my_alias
int		my_alias(t_info_shell *shell)
{
  char		**alias;
  char		**commands;

  if (((alias = cut_alias(shell->alias_tab)) == NULL)
      || ((commands = cut_commands(shell->alias_tab)) == NULL))
    return (84);
  if ((my_strcmp(shell->tab[0], "alias") == 0)
      && (shell->tab[1] != NULL)
      && (shell->tab[2] != NULL))
    replace_existing_alias(shell->tab[1], shell);
  recognize_my_alias(commands, alias, shell);
  free_all(NULL, alias);
  free_all(NULL, commands);
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %rdi
callq 0x24fd
movl $0x54, %r12d
testq %rax, %rax
je 0x29d9
movq %rax, %rbx
movq 0x30(%r14), %rdi
callq 0x25c6
testq %rax, %rax
je 0x29d9
movq %rax, %r15
movq 0x18(%r14), %rax
movq (%rax), %rdi
leaq 0x466f(%rip), %rsi      # 0x701a
callq 0x478e
testl %eax, %eax
je 0x29e8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x27f0
xorl %r12d, %r12d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4751
xorl %edi, %edi
movq %r15, %rsi
callq 0x4751
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r14), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x29b4
cmpq $0x0, 0x10(%rax)
je 0x29b4
movq %r14, %rsi
callq 0x28f3
jmp 0x29b4
nop
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/create_alias.c
// Function: alias_check
int		alias_check(t_info_shell *shell)
{
  if (my_tablen(shell->tab) == 1)
    {
      my_printf("%t", shell->alias_tab);
      return (1);
    }
  if (my_tablen(shell->tab) == 2)
    return (1);
  if ((my_strcmp(shell->tab[0], shell->tab[1]) == 0) && (shell->tab[2] != NULL))
    {
      my_printf("%s", ALIAS_ERROR);
      return (1);
    }
  if ((my_strcmp(shell->tab[0], shell->tab[1]) == 0))
    return (1);
  return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x47c2
cmpl $0x1, %eax
jne 0x2a36
movq 0x30(%r14), %rsi
leaq 0x45f8(%rip), %rdi      # 0x7020
xorl %eax, %eax
callq 0x5bde
movl $0x1, %ebx
jmp 0x2a96
movq 0x18(%r14), %rdi
callq 0x47c2
movl $0x1, %ebx
cmpl $0x2, %eax
je 0x2a96
movq 0x18(%r14), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x478e
testl %eax, %eax
je 0x2a76
movq 0x18(%r14), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x478e
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
jmp 0x2a96
movq 0x18(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x2a5d
leaq 0x4760(%rip), %rdi      # 0x71e8
leaq 0x4594(%rip), %rsi      # 0x7023
xorl %eax, %eax
callq 0x5bde
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/create_alias.c
// Function: create_valid_alias
char		*create_valid_alias(char **tab)
{
  int		i;
  char		*command;

  i = 2;
  command = NULL;
  command = my_strcat(my_strcat(my_strcat(tab[0], " ", 2), tab[1], 2), "='", 1);
  while (tab[i] != NULL)
    {
      if (i != 2)
	command = my_strcat(command, " ", 1);
      command = my_strcat(command, tab[i], 1);
      i += 1;
    }
  command = my_strcat(command, "'\0", 2);
  return (command);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x455a(%rip), %rsi      # 0x700c
movl $0x2, %edx
callq 0x4f64
movq 0x8(%rbx), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x4f64
leaq 0x4574(%rip), %rsi      # 0x7048
movq %rax, %rdi
movl $0x1, %edx
callq 0x4f64
cmpq $0x0, 0x10(%rbx)
je 0x2b25
xorl %r15d, %r15d
leaq 0x451a(%rip), %r14      # 0x700c
testq %r15, %r15
je 0x2b07
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4f64
movq 0x10(%rbx,%r15,8), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x4f64
cmpq $0x0, 0x18(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x2af2
leaq 0x451f(%rip), %rsi      # 0x704b
movq %rax, %rdi
movl $0x2, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x4f64
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/my_alias/create_alias.c
// Function: add_new_alias
char		**add_new_alias(char **tab, char *command)
{
  int		i;
  char		**new_tab;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x47c2
cltq
leaq 0x10(,%rax,8), %rdi
callq 0x2140
testq %rax, %rax
je 0x2ba8
movq %rax, %r15
movq (%rbx), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x2b86
callq 0x4dec
movq %rax, (%r15,%r12,8)
movq 0x8(%rbx,%r12,8), %rdi
incq %r12
jmp 0x2b6e
movq %r14, %rdi
callq 0x4dec
movq %rax, (%r15,%r12,8)
movq $0x0, 0x8(%r15,%r12,8)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4751
jmp 0x2bab
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_cd.c
// Function: cd_minus
int		cd_minus(char *path, char **dir, char **save)
{
  if ((my_strcmp(path, "-") == 0))
    {
      if (*dir != NULL)
	{
	  *save = getcwd((char *)NULL, 0);
	  chdir(*dir);
	}
      else
	my_printf("%s", CD_DIR);
      *dir = *save;
      return (0);
    }
  return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x4446(%rip), %rsi      # 0x706a
callq 0x478e
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x2c6d
cmpq $0x0, (%rbx)
je 0x2c50
xorl %edi, %edi
xorl %esi, %esi
callq 0x20c0
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x2090
jmp 0x2c65
leaq 0x4591(%rip), %rdi      # 0x71e8
leaq 0x440e(%rip), %rsi      # 0x706c
xorl %eax, %eax
callq 0x5bde
movq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_cd.c
// Function: my_cd
int		my_cd(t_info_shell *shell)
{
  char		*path;
  static char	*dir = NULL;
  static char	*save = NULL;

  if (cd_check(shell->tab) == 1)
    return (0);
  if (shell->tab[1] == NULL)
    path = get_path(environ, "HOME");
  else
    path = shell->tab[1];
  if ((cd_minus(path, &dir, &save)) == 0)
    return (0);
  dir = getcwd((char *)NULL, 0);
  if ((chdir(path)) == -1)
    {
      shell->exit_value = 1;
      my_printf("%s: %s.\n", path, strerror(errno));
      return (84);
    }
  free(path);
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq $-0x1, %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
leaq 0x1(%rcx), %rcx
jne 0x2c88
cmpq $0x3, %rcx
jae 0x2d04
movq 0x18(%rbx), %rax
movq 0x8(%rax), %r14
testq %r14, %r14
jne 0x2cc0
movq 0x833a(%rip), %rax      # 0xafe8
movq (%rax), %rdi
leaq 0x43d2(%rip), %rsi      # 0x708a
callq 0x4a0a
movq %rax, %r14
leaq 0x8531(%rip), %rsi      # 0xb1f8
leaq 0x8532(%rip), %rdx      # 0xb200
movq %r14, %rdi
callq 0x2c13
xorl %r15d, %r15d
testl %eax, %eax
je 0x2d1c
xorl %edi, %edi
xorl %esi, %esi
callq 0x20c0
movq %rax, 0x850b(%rip)      # 0xb1f8
movq %r14, %rdi
callq 0x2090
cmpl $-0x1, %eax
je 0x2d25
movq %r14, %rdi
callq 0x2030
jmp 0x2d1c
leaq 0x44dd(%rip), %rdi      # 0x71e8
leaq 0x433f(%rip), %rsi      # 0x7051
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x5bde
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, 0x3c(%rbx)
callq 0x2040
movl (%rax), %edi
callq 0x21d0
leaq 0x4350(%rip), %rdi      # 0x708f
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5bde
movl $0x54, %r15d
jmp 0x2d1c
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_display_env.c
// Function: my_display_env
int		my_display_env(t_info_shell *shell)
{
  int		i;

  (void)shell;
  i = 0;
  while (environ[i] != NULL)
    {
      my_printf("%s\n", environ[i]);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8288(%rip), %r14      # 0xafe8
movq (%r14), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2d92
movl $0x8, %r15d
leaq 0x4637(%rip), %rbx      # 0x73af
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5bde
movq (%r14), %rax
movq (%rax,%r15), %rsi
addq $0x8, %r15
testq %rsi, %rsi
jne 0x2d78
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_setenv.c
// Function: check
int		check(t_info_shell *shell)
{
  int		i;

  i = 0;
  if (shell->tab[1] == NULL)
    {
      my_display_env(shell);
      return (0);
    }
  if (verif_first_letter(shell->tab[1]) == 1)
    {
      my_printf("%s%s", SETENV_NAME, SETENV_LETTER);
      return (1);
    }
  if (my_str_isalpha(shell->tab[1]) == 1)
    {
      my_printf("%s %s\n", SETENV_NAME, SETENV_ALPHA);
      return (1);
    }
  while (shell->tab[i++] != NULL)
    if (i > 3)
      {
	my_printf("%s", SETENV_AV);
	return (1);
      }
  return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2dce
callq 0x4dda
cmpl $0x1, %eax
jne 0x2dda
leaq 0x42da(%rip), %rdi      # 0x7098
leaq 0x42d8(%rip), %rsi      # 0x709d
leaq 0x42ec(%rip), %rdx      # 0x70b8
jmp 0x2e01
movq %rbx, %rdi
callq 0x2d54
xorl %eax, %eax
jmp 0x2e0d
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x4dac
cmpl $0x1, %eax
jne 0x2e0f
leaq 0x4410(%rip), %rdi      # 0x7203
leaq 0x42a3(%rip), %rsi      # 0x709d
leaq 0x42ce(%rip), %rdx      # 0x70cf
xorl %eax, %eax
callq 0x5bde
movl $0x1, %eax
popq %rbx
retq
movq 0x18(%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq $0x0, (%rcx,%rdx,8)
je 0x2e0d
incq %rdx
cmpq $0x4, %rdx
jne 0x2e17
leaq 0x43ba(%rip), %rdi      # 0x71e8
leaq 0x42bb(%rip), %rsi      # 0x70f0
xorl %eax, %eax
callq 0x5bde
jmp 0x2e08
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_setenv.c
// Function: my_set_env
int		my_set_env(t_info_shell *shell)
{
  if (check(shell) == 1)
    {
      shell->exit_value = 1;
      return (1);
    }
  if (shell->tab[2] == NULL)
    {
      if ((shell->tab[2] = malloc(sizeof(char) * 1)) == NULL)
	return (84);
      shell->tab[2][0] = '\0';
    }
  setenv(shell->tab[1], shell->tab[2], 1);
  return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2d9c
testl %eax, %eax
je 0x2e5c
movl $0x1, 0x3c(%rbx)
movl $0x1, %eax
jmp 0x2e9d
movq 0x18(%rbx), %r14
cmpq $0x0, 0x10(%r14)
jne 0x2e85
movl $0x1, %edi
callq 0x2140
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2ea5
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movl $0x1, %edx
callq 0x2060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x54, %eax
jmp 0x2e9d
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_unsetenv.c
// Function: check_tab
int		check_tab(char **tab)
{
  int		i;

  i = 0;
  while (tab[i] != NULL)
    i += 1;
  if (i == 1)
    {
      my_printf("unsetenv: Too few arguments.\n");
      return (1);
    }
  return (0);
}

// Assembly:
xorl %ecx, %ecx
cmpq $0x0, (%rdi,%rcx,8)
leaq 0x1(%rcx), %rcx
jne 0x2eae
xorl %eax, %eax
cmpq $0x2, %rcx
jne 0x2ed9
pushq %rax
leaq 0x4244(%rip), %rdi      # 0x710d
xorl %eax, %eax
callq 0x5bde
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/builtin/my_unsetenv.c
// Function: my_unset_env
int		my_unset_env(t_info_shell *shell)
{
  int		i;

  if (check_tab(shell->tab) == 1)
    return (1);
  i = 1;
  while (shell->tab[i] != NULL)
    {
      if (shell->tab[i] == NULL)
	break ;
      unsetenv(shell->tab[i]);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
leaq 0x1(%rcx), %rcx
jne 0x2ee7
cmpq $0x2, %rcx
jne 0x2f0d
leaq 0x420e(%rip), %rdi      # 0x710d
xorl %eax, %eax
callq 0x5bde
movl $0x1, %ebp
jmp 0x2f38
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2f38
movl $0x10, %r14d
callq 0x2180
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x2f22
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execute_command.c
// Function: core_exec
char		*core_exec(t_info_shell *shell, char *env_path,
			   char *valid_path, char **paths)
{
  int		i;

  i = 0;
  while (paths[i] != NULL)
    {
      if ((paths[i] = my_strcat(paths[i], "/", 1)) == NULL
	  || (shell->tab[0] != NULL
	      && (paths[i] = my_strcat(paths[i], shell->tab[0], 1)) == NULL))
	return (NULL);
      if (shell->tab[0] != NULL && access(shell->tab[0], X_OK) != -1)
	{
	  valid_path = my_strcat(shell->tab[0], NULL, 2);
	  free_all(env_path, paths);
	  return (valid_path);
	}
      if (shell->tab[0] != NULL && access(paths[i], X_OK) != -1)
	{
	  valid_path = my_strcat(paths[i], NULL, 2);
	  free_all(env_path, paths);
	  return (valid_path);
	}
      i += 1;
    }
  return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x300d
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x41a4(%rip), %r12      # 0x7131
movq %rcx, %r13
movq %r12, %rsi
movl $0x1, %edx
callq 0x4f64
movq %rax, (%r13)
testq %rax, %rax
je 0x300d
movq 0x18(%r15), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x2fc8
movq %rax, %rdi
movl $0x1, %edx
callq 0x4f64
movq %rax, (%r13)
testq %rax, %rax
je 0x300d
movq 0x18(%r15), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2fe3
movl $0x1, %esi
callq 0x2170
cmpl $-0x1, %eax
jne 0x3019
movq 0x18(%r15), %rax
cmpq $0x0, (%rax)
je 0x3000
movq (%r13), %rdi
movl $0x1, %esi
callq 0x2170
cmpl $-0x1, %eax
jne 0x301d
movq 0x8(%r13), %rdi
addq $0x8, %r13
testq %rdi, %rdi
jne 0x2f90
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r15), %r13
movq (%r13), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x4f64
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4751
movq %r15, %rax
jmp 0x300f
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execute_command.c
// Function: is_valid_command
char		*is_valid_command(t_info_shell *shell)
{
  char		*without_path;
  char		*env_path;
  char		*valid_path;
  char		**paths;
  char		*output;

  if ((env_path = get_path(environ, "PATH")) == NULL)
    env_path = shell->path_save;
  if ((paths = my_str_to_wordtab(env_path, ':')) == NULL)
    {
      without_path = my_strcat(PATH, PATH_TWO, 2);
      without_path = my_strcat(without_path, PATH_THREE, 2);
      paths = my_str_to_wordtab(without_path, ':');
    }
  valid_path = NULL;
  if ((output = core_exec(shell, env_path, valid_path, paths)) != NULL)
    return (output);
  free_all(env_path, paths);
  return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7f99(%rip), %rax      # 0xafe8
movq (%rax), %rdi
leaq 0x40da(%rip), %rsi      # 0x7133
callq 0x4a0a
movq %rax, %rbx
testq %rax, %rax
jne 0x306a
movq 0x10(%r14), %rbx
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x4cfb
movq %rax, %r15
testq %rax, %rax
jne 0x30bb
leaq 0x40b2(%rip), %rdi      # 0x7138
leaq 0x40d4(%rip), %rsi      # 0x7161
movl $0x2, %edx
callq 0x4f64
leaq 0x40f0(%rip), %rsi      # 0x718e
movq %rax, %rdi
movl $0x2, %edx
callq 0x4f64
movq %rax, %rdi
movl $0x3a, %esi
callq 0x4cfb
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2f68
testq %rax, %rax
jne 0x30db
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4751
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execute_command.c
// Function: execute_command
int		execute_command(t_info_shell *shell)
{
  int		i;
  char		*valid_path;

  i = 0;
  while (i < 11)
    {
      if (my_strcmp(shell->tab[0], g_key[i].code) == 0)
	{
	  g_key[i].fc(shell);
	  return (shell->exit_value);
	}
      i += 1;
    }
  valid_path = is_valid_command(shell);
  shell->exit_value = exec(shell, valid_path);
  return (shell->exit_value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %r14d
leaq 0x7a7a(%rip), %r15      # 0xab70
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movq -0x8(%r14,%r15), %rsi
callq 0x478e
testl %eax, %eax
je 0x3130
addq $0x10, %r14
cmpq $0xb8, %r14
jne 0x30f6
movq %rbx, %rdi
callq 0x3040
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33e4
movl %eax, 0x3c(%rbx)
jmp 0x313a
movq %rbx, %rdi
callq *(%r14,%r15)
movl 0x3c(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execution_in_chain.c
// Function: change_command
int		change_command(t_info_shell *shell)
{
  t_count	ct;
  char		*tmp;

  (1 == 1) ? (ct.i = 0, ct.j = 0, ct.k = 0) : 1;
  if ((tmp = malloc(sizeof(char) * (my_strlen(shell->command)))) == NULL)
    return (84);
  if ((shell->mem = malloc(sizeof(char)
			   * (my_strlen(shell->command)))) == NULL)
    return (84);
  while (shell->command[ct.i] != ';')
    {
      if (shell->command[ct.i] == '\0')
	return (free_tmp(shell, tmp));
      tmp[ct.j++] = shell->command[ct.i++];
    }
  tmp[ct.j] = '\0';
  while (shell->command[++ct.i] != '\0')
    shell->mem[ct.k++] = shell->command[ct.i];
  shell->mem[ct.k] = '\0';
  shell->command = my_strdup(tmp);
  free(tmp);
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4740
movslq %eax, %rdi
callq 0x2140
movl $0x54, %r15d
testq %rax, %rax
je 0x3210
movq %rax, %r14
movq (%rbx), %rdi
callq 0x4740
movslq %eax, %rdi
callq 0x2140
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3210
movq (%rbx), %rcx
xorl %eax, %eax
movzbl (%rcx,%rax), %edx
cmpl $0x3b, %edx
je 0x31b2
testl %edx, %edx
je 0x31a2
movb %dl, (%r14,%rax)
incq %rax
jmp 0x318c
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4800
movl %eax, %ecx
movb $0x0, (%r14,%rcx)
movq (%rbx), %rcx
leal 0x1(%rax), %edx
movb (%rcx,%rdx), %sil
xorl %r15d, %r15d
testb %sil, %sil
je 0x31f3
movl $0x2, %edx
xorl %ecx, %ecx
movq 0x8(%rbx), %rdi
movb %sil, (%rdi,%rcx)
incq %rcx
movq (%rbx), %rsi
addq %rdx, %rsi
movb (%rax,%rsi), %sil
incq %rdx
testb %sil, %sil
jne 0x31d2
movl %ecx, %eax
jmp 0x31f5
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %r14, %rdi
callq 0x4dec
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2030
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execution_in_chain.c
// Function: change_tab
int		change_tab(t_info_shell *shell)
{
  t_count	ct;
  char		**tmp;

  ct.i = 0;
  ct.j = 0;
  ct.k = 0;
  if (((tmp = malloc(sizeof(char *) * (shell->tablen + 1))) == NULL)
      || ((shell->tab_mem = malloc(sizeof(char *) * shell->tablen)) == NULL))
    return (84);
  while (my_strcmp(shell->tab[ct.i], ";") != 0)
    {
      if (shell->tab[ct.i] == NULL)
	{
	  shell->tab_mem[0] = NULL;
	  return (0);
	}
      tmp[ct.j++] = shell->tab[ct.i++];
    }
  tmp[ct.j] = NULL;
  while (shell->tab[++ct.i] != NULL)
    shell->tab_mem[ct.k++] = my_strdup(shell->tab[ct.i]);
  shell->tab_mem[ct.k] = NULL;
  shell->tab = tmp;
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x38(%rdi), %r12
leaq 0x8(,%r12,8), %rdi
callq 0x2140
movl $0x54, %r15d
testq %rax, %rax
je 0x332b
movq %rax, %r14
shlq $0x3, %r12
movq %r12, %rdi
callq 0x2140
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x332b
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x3f73(%rip), %rsi      # 0x71e2
callq 0x478e
testl %eax, %eax
je 0x32b3
xorl %ecx, %ecx
leaq 0x3f61(%rip), %r15      # 0x71e2
movq 0x18(%rbx), %rax
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x3309
leaq 0x1(%rcx), %r12
movq %rax, (%r14,%rcx,8)
movq 0x18(%rbx), %rax
movq 0x8(%rax,%rcx,8), %rdi
movq %r15, %rsi
callq 0x478e
movq %r12, %rcx
testl %eax, %eax
jne 0x3281
movl %r12d, %eax
jmp 0x32b8
xorl %eax, %eax
xorl %r12d, %r12d
movq $0x0, (%r14,%rax,8)
movq 0x18(%rbx), %rax
movslq %r12d, %rcx
movq 0x8(%rax,%rcx,8), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x3319
movl %r12d, %eax
leaq 0x10(,%rax,8), %r12
xorl %ecx, %ecx
movq %rcx, %r13
callq 0x4dec
movq 0x20(%rbx), %rdx
leaq 0x1(%r13), %rcx
movq %rax, (%rdx,%r13,8)
movq 0x18(%rbx), %rax
addq %r12, %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
jne 0x32e1
movl %ecx, %eax
jmp 0x331b
movq 0x20(%rbx), %rax
movq $0x0, (%rax)
xorl %r15d, %r15d
jmp 0x332b
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
movq %r14, 0x18(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/execution_in_chain.c
// Function: execution_in_chain
int		execution_in_chain(t_info_shell *shell)
{
  wordexp_t     p;
  char          **wordextab;

  shell->mem = BOOL;
  while (shell->mem != NULL)
    {
      if (((change_command(shell)) == 84)
	  || ((change_tab(shell)) == 84)
	  || ((my_magic_quote(shell)) == 84))
	return (84);
      if ((wordexp(shell->command, &p, 0)) == 0)
	{
	  wordextab = p.we_wordv;
	  shell->tab = copy_my_tab(wordextab);
	  wordfree(&p);
	}
      if (((my_alias(shell)) == 84) || ((parsing(shell)) == 84))
	return (84);
      shell->command = shell->mem;
      shell->tab = shell->tab_mem;
    }
  return (shell->exit_value);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3cc4(%rip), %rax      # 0x700e
movq %rax, 0x8(%rdi)
leaq 0x8(%rsp), %r14
movl $0x54, %ebp
movq %rbx, %rdi
callq 0x3140
cmpl $0x54, %eax
je 0x33d7
movq %rbx, %rdi
callq 0x3219
cmpl $0x54, %eax
je 0x33d7
movq %rbx, %rdi
callq 0x5a05
cmpl $0x54, %eax
je 0x33d7
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21c0
testl %eax, %eax
jne 0x33a6
movq 0x10(%rsp), %rdi
callq 0x4014
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x296a
cmpl $0x54, %eax
je 0x33d7
movq %rbx, %rdi
callq 0x37a7
cmpl $0x54, %eax
je 0x33d7
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, (%rbx)
movq %rcx, 0x18(%rbx)
testq %rax, %rax
jne 0x3358
movl 0x3c(%rbx), %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3471
testl %eax, %eax
je 0x347c
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 0x3437
cmpl $0xb, %ecx
jne 0x3444
testb %al, %al
js 0x3449
leaq 0x3e32(%rip), %rdi      # 0x7267
jmp 0x3450
testb %al, %al
js 0x345e
leaq 0x3e5b(%rip), %rdi      # 0x729d
jmp 0x3465
movzbl %ah, %ebp
jmp 0x3471
leaq 0x3df5(%rip), %rdi      # 0x7245
xorl %eax, %eax
callq 0x5bde
movl $0x8b, %ebp
jmp 0x3471
leaq 0x3e16(%rip), %rdi      # 0x727b
xorl %eax, %eax
callq 0x5bde
movl $0x88, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%r14), %rsi
testq %rbx, %rbx
jne 0x349f
movq (%rsi), %rsi
leaq 0x3d55(%rip), %rdi      # 0x71e4
leaq 0x3d55(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5bde
jmp 0x34b9
movq 0x7b42(%rip), %rax      # 0xafe8
movq (%rax), %rdx
movq %rbx, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x34c3
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x8, (%rax)
jne 0x34f6
leaq 0x3d21(%rip), %rdi      # 0x71ff
leaq 0x3d25(%rip), %rdx      # 0x720a
leaq 0x3d31(%rip), %rcx      # 0x721d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5bde
cmpl $0xd, (%r14)
jne 0x351b
leaq 0x3ce1(%rip), %rdi      # 0x71e4
leaq 0x3d27(%rip), %rdx      # 0x7231
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5bde
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x357c
xorl %r15d, %r15d
leaq 0x76dd(%rip), %r14      # 0xac20
movl $0x8, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq -0x8(%r12,%r14), %rsi
callq 0x478e
testl %eax, %eax
je 0x3587
addq $0x10, %r12
cmpq $0x98, %r12
jne 0x3549
movq 0x18(%rbx), %rax
cmpq $0x0, 0x8(%rax,%r15,8)
leaq 0x1(%r15), %r15
jne 0x3543
movl $0x0, 0x40(%rbx)
xorl %eax, %eax
jmp 0x3598
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_O1/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 0x47c2
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2140
testq %rax, %rax
je 0x366a
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x47c2
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2140
testq %rax, %rax
je 0x366a
movq %rax, %r15
movq 0x18(%r14), %rax
movq (%rax), %rdi
leaq 0x3cb0(%rip), %rsi      # 0x72b1
callq 0x478e
testl %eax, %eax
je 0x3671
movq %r12, (%rsp)
xorl %r12d, %r12d
leaq 0x3c9c(%rip), %r13      # 0x72b4
leaq 0x3c92(%rip), %rbp      # 0x72b1
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r13, %rsi
callq 0x478e
testl %eax, %eax
je 0x3665
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x36ea
callq 0x4dec
movq %rax, (%r15,%r12,8)
movq 0x18(%r14), %rax
movq 0x8(%rax,%r12,8), %rdi
incq %r12
movq %rbp, %rsi
callq 0x478e
testl %eax, %eax
jne 0x361f
movslq %r12d, %rcx
jmp 0x3676
xorl %ebx, %ebx
jmp 0x36f4
xorl %ecx, %ecx
xorl %r12d, %r12d
movq $0x0, (%r15,%r12,8)
movq 0x18(%r14), %rax
cmpq $0x0, (%rax,%rcx,8)
je 0x36d5
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 0x4dec
movq %rax, (%rbx)
movq 0x18(%r14), %rax
addq $0x8, %rbx
cmpq $0x0, (%rax,%r13)
leaq 0x8(%r13), %r13
jne 0x36a9
sarq $0x20, %r12
movq (%rsp), %rbx
jmp 0x36dc
movq $-0x1, %r12
movq $0x0, (%rbx,%r12,8)
movq %r15, 0x18(%r14)
jmp 0x36f4
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_O1/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 0x3774
movq %rsi, %rbx
xorl %r13d, %r13d
leaq 0x3b86(%rip), %r15      # 0x72b1
leaq 0x3b82(%rip), %r12      # 0x72b4
movq %r15, %rsi
callq 0x478e
testl %eax, %eax
je 0x3766
movq 0x18(%r14), %rax
movq (%rax,%r13), %rdi
movq %r12, %rsi
callq 0x478e
testl %eax, %eax
je 0x376d
movq 0x18(%r14), %rax
movq 0x8(%rax,%r13), %rdi
addq $0x8, %r13
testq %rdi, %rdi
jne 0x3732
jmp 0x3774
movl $0x1, %eax
jmp 0x3772
movl $0x2, %eax
movl %eax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MaxenceEpitech[P]42sh/execution/parsing.c
// Function: detect_or_and
int		detect_or_and(t_info_shell *shell, int marck)
{
  if (marck == AND)
    if (shell->exit_value == 1)
      return (1);
  if (marck == OR)
    if (shell->exit_value == 0)
      return (1);
  return (0);
}

// Assembly:
cmpl $0x2, %esi
je 0x3798
cmpl $0x1, %esi
jne 0x379e
movl $0x1, %eax
cmpl $0x1, 0x3c(%rdi)
je 0x37a0
cmpl $0x2, %esi
jne 0x379e
cmpl $0x0, 0x3c(%rdi)
je 0x37a1
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x47c2
testl %eax, %eax
je 0x3855
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 0x3706
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35a4
testq %rax, %rax
je 0x3858
movq %rax, %r12
movq %rbx, %rdi
callq 0x3524
cmpl $0x54, %eax
je 0x3858
cmpl $0x0, 0x40(%rbx)
jne 0x3824
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax)
je 0x3824
movq %rbx, %rdi
callq 0x30e1
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
je 0x383d
cmpl $0x1, %eax
jne 0x3843
cmpl $0x1, 0x3c(%rbx)
je 0x3855
cmpl $0x2, %eax
jne 0x3843
cmpl $0x0, 0x3c(%rbx)
je 0x3855
movq %r12, 0x18(%rbx)
movl $0x0, 0x40(%rbx)
cmpl $0x0, 0x8(%rsp)
jne 0x37e1
movl 0x3c(%rbx), %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x47c2
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x2140
testq %rax, %rax
je 0x38f0
movq %rax, %r14
movq (%rbx), %rdi
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x38dc
xorl %r12d, %r12d
movq %r15, %rsi
callq 0x478e
testl %eax, %eax
jne 0x38b3
addl $0x2, %r13d
movslq %r13d, %rbp
movq (%rbx,%rbp,8), %rdi
testq %rdi, %rdi
je 0x38d9
callq 0x4dec
movq %rax, (%r14,%r12,8)
leal 0x1(%rbp), %r13d
incq %r12
movq 0x8(%rbx,%rbp,8), %rdi
testq %rdi, %rdi
jne 0x38a3
movl %r12d, %r13d
movq $0x0, (%r14,%r13,8)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4751
jmp 0x38f3
xorl %r14d, %r14d
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_O1/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 0x3932
testl %eax, %eax
je 0x393d
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 0x3338
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x392a(%rip), %r14      # 0x72ba
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x478e
addq $0x8, %r15
testl %eax, %eax
jne 0x3990
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4dec
movl $0x54, %ebp
testq %rax, %rax
je 0x39f5
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x38ed(%rip), %rsi      # 0x72ba
callq 0x3868
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x39f5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3905
cmpl $0x54, %eax
je 0x39f5
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_O1/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 0x3a31
testl %eax, %eax
je 0x3a3c
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 0x3a6f
leaq 0x3871(%rip), %rdi      # 0x72c5
leaq 0x3613(%rip), %rdx      # 0x706e
movq %r14, %rsi
xorl %eax, %eax
callq 0x5bde
movl $0x54, %edi
callq 0x21b0
movl %eax, %ebp
movl %eax, %edi
xorl %esi, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x3338
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x380c(%rip), %r14      # 0x72b7
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x478e
addq $0x8, %r15
testl %eax, %eax
jne 0x3aab
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4dec
movl $0x54, %ebp
testq %rax, %rax
je 0x3b10
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x37cf(%rip), %rsi      # 0x72b7
callq 0x3868
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3b10
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a04
cmpl $0x54, %eax
je 0x3b10
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_O1/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 0x47c2
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2140
testq %rax, %rax
je 0x3bba
movq %rax, %r15
leaq 0x8(%rbx), %r13
xorl %ebp, %ebp
leaq 0x375b(%rip), %r12      # 0x72b5
movq -0x8(%r13), %rdi
movq %r12, %rsi
callq 0x478e
incq %rbp
addq $0x8, %r13
testl %eax, %eax
jne 0x3b5a
movl %ebp, %eax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x3bbe
movq %r14, (%rsp)
leaq (%rbx,%rax,8), %r14
xorl %r12d, %r12d
movq %r13, %rax
movq %rax, %rbp
callq 0x4dec
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 0x3b8a
movl %r12d, %eax
movq (%rsp), %r14
jmp 0x3bc0
xorl %ebx, %ebx
jmp 0x3bcd
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_O1/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 0x3c0b
movq 0x18(%rbx), %rax
movq (%rax), %rsi
leaq 0x35e7(%rip), %rdi      # 0x71e4
leaq 0x35e7(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5bde
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
callq 0x3040
testq %rax, %rax
jne 0x3c23
movl $0x1, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c41
xorl %eax, %eax
cmpq $0x0, (%rsi)
jne 0x3c5b
leaq 0x3683(%rip), %rdi      # 0x72cb
xorl %eax, %eax
callq 0x5bde
movl $0x1, 0x3c(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3cbb
callq 0x21f0
cmpl $-0x1, %eax
je 0x3cbb
testl %eax, %eax
je 0x3cc8
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 0x37a7
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 0x37a7
movl 0x3c(%rbx), %edi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x3b20
movq %rax, 0x18(%rbx)
movl $0x54, %r15d
testq %rax, %rax
je 0x3db2
movq %rax, %r14
movl $0x1, 0x40(%rbx)
cmpq $0x0, (%rax)
je 0x3d97
movq 0x8(%rsp), %r12
cmpq $0x0, (%r12)
je 0x3d97
callq 0x21f0
cmpl $-0x1, %eax
je 0x3db2
testl %eax, %eax
je 0x3dc1
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 0x3bdf
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4751
xorl %edi, %edi
movq %r14, %rsi
callq 0x4751
jmp 0x3db2
leaq 0x352d(%rip), %rdi      # 0x72cb
xorl %eax, %eax
callq 0x5bde
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 0x3c5d
movl %eax, %edi
callq 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3e10
testl %eax, %eax
je 0x3e1b
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 0x3e4c
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 0x30e1
movl %ebp, %edi
callq 0x20d0
movl 0x3c(%rbx), %edi
callq 0x21b0