LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq 0x18(%rdi), %rdi
callq 0x2b0e
xorl %ebx, %ebx
testl %eax, %eax
je 0x2bc2
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
jne 0x2be8
movq 0x8412(%rip), %rax      # 0xafe8
movq (%rax), %rdi
leaq 0x44aa(%rip), %rsi      # 0x708a
callq 0x45e9
movq %rax, %r15
leaq 0x8609(%rip), %rsi      # 0xb1f8
leaq 0x860a(%rip), %rdx      # 0xb200
movq %r15, %rdi
callq 0x2b43
testl %eax, %eax
je 0x2bba
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x20c0
movq %rax, 0x85e4(%rip)      # 0xb1f8
movq %r15, %rdi
callq 0x2090
cmpl $-0x1, %eax
je 0x2c2b
movq %r15, %rdi
callq 0x2030
jmp 0x2bba
movl $0x1, 0x3c(%r14)
callq 0x2040
movl (%rax), %edi
callq 0x21c0
leaq 0x4449(%rip), %rdi      # 0x708f
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5648
pushq $0x54
popq %rbx
jmp 0x2bba
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x8380(%rip), %r14      # 0xafe8
leaq 0x4740(%rip), %rbx      # 0x73af
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x2c8e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5648
addq $0x8, %r15
jmp 0x2c72
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2cca
callq 0x494f
cmpl $0x1, %eax
jne 0x2cd6
leaq 0x43de(%rip), %rdi      # 0x7098
leaq 0x43dc(%rip), %rsi      # 0x709d
leaq 0x43f0(%rip), %rdx      # 0x70b8
jmp 0x2cfd
movq %rbx, %rdi
callq 0x2c5c
xorl %eax, %eax
jmp 0x2d07
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x492c
cmpl $0x1, %eax
jne 0x2d09
leaq 0x4514(%rip), %rdi      # 0x7203
leaq 0x43a7(%rip), %rsi      # 0x709d
leaq 0x43d2(%rip), %rdx      # 0x70cf
xorl %eax, %eax
callq 0x5648
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x18(%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq $0x0, (%rcx,%rdx,8)
je 0x2d07
incq %rdx
cmpq $0x4, %rdx
jne 0x2d11
leaq 0x44c0(%rip), %rdi      # 0x71e8
leaq 0x43c1(%rip), %rsi      # 0x70f0
xorl %eax, %eax
callq 0x5648
jmp 0x2d04
// File: /workspace/github_c_makefile_star2_O2/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 0x2c98
testl %eax, %eax
je 0x2d54
movl $0x1, 0x3c(%rbx)
pushq $0x1
popq %rax
jmp 0x2d93
movq 0x18(%rbx), %r14
movq 0x10(%r14), %rsi
testq %rsi, %rsi
jne 0x2d85
pushq $0x1
popq %rdi
callq 0x2130
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2d9b
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x18(%rbx), %r14
movq 0x10(%r14), %rsi
movq 0x8(%r14), %rdi
pushq $0x1
popq %rdx
callq 0x2060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x54
jmp 0x2d51
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2da2
xorl %eax, %eax
cmpq $0x2, %rcx
jne 0x2dcb
pushq %rax
leaq 0x4350(%rip), %rdi      # 0x710d
xorl %eax, %eax
callq 0x5648
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2da0
testl %eax, %eax
je 0x2de5
pushq $0x1
popq %rax
jmp 0x2e03
pushq $0x8
popq %r14
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x2e01
callq 0x2170
addq $0x8, %r14
jmp 0x2de9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x42e2(%rip), %r12      # 0x7131
pushq $0x1
popq %rbp
movq %rcx, %r13
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2ec8
movq %r12, %rsi
movl %ebp, %edx
callq 0x4abc
movq %rax, (%r13)
testq %rax, %rax
je 0x2ec8
movq 0x18(%r15), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x2ec2
movq %rax, %rdi
movl %ebp, %edx
callq 0x4abc
movq %rax, (%r13)
testq %rax, %rax
je 0x2ec8
movq 0x18(%r15), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2ec2
movl %ebp, %esi
callq 0x2160
movq 0x18(%r15), %rcx
cmpl $-0x1, %eax
jne 0x2edc
cmpq $0x0, (%rcx)
je 0x2ec2
movq (%r13), %rdi
movl %ebp, %esi
callq 0x2160
cmpl $-0x1, %eax
jne 0x2ed9
addq $0x8, %r13
jmp 0x2e55
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rcx
movq (%rcx), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x4abc
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x436b
movq %r15, %rax
jmp 0x2eca
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x80db(%rip), %rax      # 0xafe8
movq (%rax), %rdi
leaq 0x421c(%rip), %rsi      # 0x7133
callq 0x45e9
movq %rax, %rbx
testq %rax, %rax
jne 0x2f28
movq 0x10(%r14), %rbx
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0x4889
movq %rax, %r15
testq %rax, %rax
jne 0x2f72
leaq 0x41f6(%rip), %rdi      # 0x7138
leaq 0x4218(%rip), %rsi      # 0x7161
pushq $0x2
popq %rbp
movl %ebp, %edx
callq 0x4abc
leaq 0x4234(%rip), %rsi      # 0x718e
movq %rax, %rdi
movl %ebp, %edx
callq 0x4abc
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x4889
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2e34
movq %rax, %r14
testq %rax, %rax
jne 0x2f93
movq %rbx, %rdi
movq %r15, %rsi
callq 0x436b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
leaq 0x7bbe(%rip), %r14      # 0xab70
leaq 0x10(%rcx), %r15
cmpq $0xc0, %r15
je 0x2fe3
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movq (%rcx,%r14), %rsi
callq 0x43a1
movq %r15, %rcx
testl %eax, %eax
jne 0x2fb2
movq %rbx, %rdi
callq *-0x8(%r15,%r14)
movl 0x3c(%rbx), %eax
jmp 0x2ff9
movq %rbx, %rdi
callq 0x2efc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3234
movl %eax, 0x3c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x435c
movslq %eax, %rdi
callq 0x2130
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x30af
movq %rax, %r14
movq (%rbx), %rdi
callq 0x435c
movslq %eax, %rdi
callq 0x2130
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x30af
movq (%rbx), %rcx
xorl %eax, %eax
movzbl (%rcx,%rax), %edx
cmpl $0x3b, %edx
je 0x3069
testl %edx, %edx
je 0x305a
movb %dl, (%r14,%rax)
incq %rax
jmp 0x3044
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4402
movl %eax, %edx
movb $0x0, (%r14,%rdx)
pushq $0x1
popq %rsi
xorl %edx, %edx
addq %rsi, %rcx
movb (%rax,%rcx), %dil
movq 0x8(%rbx), %rcx
testb %dil, %dil
je 0x3094
movb %dil, (%rcx,%rdx)
incq %rdx
movq (%rbx), %rcx
incq %rsi
jmp 0x3075
movl %edx, %eax
movb $0x0, (%rcx,%rax)
movq %r14, %rdi
callq 0x4960
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x38(%rdi), %r15
leaq 0x8(,%r15,8), %rdi
callq 0x2130
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x317a
movq %rax, %r14
shlq $0x3, %r15
movq %r15, %rdi
callq 0x2130
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x317a
movq 0x18(%rbx), %rax
xorl %r12d, %r12d
leaq 0x40da(%rip), %r15      # 0x71e2
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x43a1
testl %eax, %eax
je 0x312e
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rcx
testq %rcx, %rcx
je 0x3170
movq %rcx, (%r14,%r12,8)
incq %r12
jmp 0x3108
movl %r12d, %eax
andq $0x0, (%r14,%rax,8)
incq %r12
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x315e
callq 0x4960
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
incq %r12
jmp 0x313c
movq 0x20(%rbx), %rax
movl %r15d, %ecx
andq $0x0, (%rax,%rcx,8)
movq %r14, 0x18(%rbx)
jmp 0x3178
movq 0x20(%rbx), %rax
andq $0x0, (%rax)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x3e76(%rip), %rax      # 0x700e
movq %rax, 0x8(%rdi)
pushq $0x54
popq %rbx
leaq 0x8(%rsp), %r15
testq %rax, %rax
je 0x3222
movq %r14, %rdi
callq 0x3000
cmpl $0x54, %eax
je 0x3226
movq %r14, %rdi
callq 0x30b6
cmpl $0x54, %eax
je 0x3226
movq %r14, %rdi
callq 0x547c
cmpl $0x54, %eax
je 0x3226
movq (%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x21b0
testl %eax, %eax
jne 0x31f7
movq 0x10(%rsp), %rdi
callq 0x3d5c
movq %rax, 0x18(%r14)
movq %r15, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x28c4
cmpl $0x54, %eax
je 0x3226
movq %r14, %rdi
callq 0x3583
cmpl $0x54, %eax
je 0x3226
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq %rax, (%r14)
movq %rcx, 0x18(%r14)
jmp 0x31a4
movl 0x3c(%r14), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x21e0
cmpl $-0x1, %eax
je 0x327c
testl %eax, %eax
je 0x32c3
leaq 0x4(%rsp), %rbx
pushq $0x2
popq %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x2140
movl (%rbx), %eax
movl %eax, %ecx
andl $0x7f, %ecx
cmpl $0x8, %ecx
je 0x3281
cmpl $0xb, %ecx
jne 0x328e
testb %al, %al
js 0x3293
leaq 0x3fed(%rip), %rdi      # 0x7267
jmp 0x329a
pushq $0x54
popq %rax
jmp 0x32bb
testb %al, %al
js 0x32a8
leaq 0x4011(%rip), %rdi      # 0x729d
jmp 0x32af
movzbl %ah, %eax
jmp 0x32bb
leaq 0x3fab(%rip), %rdi      # 0x7245
xorl %eax, %eax
callq 0x5648
movl $0x8b, %eax
jmp 0x32bb
leaq 0x3fcc(%rip), %rdi      # 0x727b
xorl %eax, %eax
callq 0x5648
movl $0x88, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%r14), %rsi
testq %rbx, %rbx
jne 0x32e6
movq (%rsi), %rsi
leaq 0x3f0e(%rip), %rdi      # 0x71e4
leaq 0x3f0e(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5648
jmp 0x3300
movq 0x7cfb(%rip), %rax      # 0xafe8
movq (%rax), %rdx
movq %rbx, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x3308
pushq $0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x3340
leaq 0x3eda(%rip), %rdi      # 0x71ff
leaq 0x3ede(%rip), %rdx      # 0x720a
leaq 0x3eea(%rip), %rcx      # 0x721d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5648
movl (%r14), %eax
cmpl $0xd, %eax
jne 0x3364
leaq 0x3e98(%rip), %rdi      # 0x71e4
leaq 0x3ede(%rip), %rdx      # 0x7231
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5648
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
leaq 0x789f(%rip), %r14      # 0xac20
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0x33d8
xorl %ecx, %ecx
leaq 0x10(%rcx), %r12
cmpq $0xa0, %r12
je 0x33b5
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rcx,%r14), %rsi
callq 0x43a1
movq %r12, %rcx
testl %eax, %eax
jne 0x338e
jmp 0x33ba
incq %r15
jmp 0x3381
movq %rbx, %rdi
callq *-0x8(%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
andl $0x0, 0x40(%rbx)
xorl %eax, %eax
jmp 0x33cc
// File: /workspace/github_c_makefile_star2_O2/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 0x43d0
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2130
testq %rax, %rax
je 0x3489
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x43d0
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2130
testq %rax, %rax
je 0x3489
movq %rax, %r15
movq %r12, (%rsp)
pushq $0x8
popq %r12
leaq 0x3e77(%rip), %r13      # 0x72b1
leaq 0x3e73(%rip), %rbp      # 0x72b4
movq 0x18(%r14), %rax
movq -0x8(%rax,%r12), %rdi
movq %r13, %rsi
callq 0x43a1
testl %eax, %eax
je 0x348d
movq 0x18(%r14), %rax
movq -0x8(%rax,%r12), %rdi
movq %rbp, %rsi
callq 0x43a1
testl %eax, %eax
je 0x348d
movq 0x18(%r14), %rax
movq -0x8(%rax,%r12), %rdi
testq %rdi, %rdi
je 0x34e3
callq 0x4960
movq %rax, -0x8(%r15,%r12)
addq $0x8, %r12
jmp 0x3441
xorl %ebx, %ebx
jmp 0x34ea
andq $0x0, -0x8(%r15,%r12)
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rbp      # imm = 0x100000000
movq %rbx, (%rsp)
movq 0x18(%r14), %rax
cmpq $0x0, -0x8(%rax,%r12)
je 0x34d0
movq (%rax,%r12), %rdi
callq 0x4960
movq %rax, (%rbx)
addq $0x8, %r12
addq %rbp, %r13
addq $0x8, %rbx
jmp 0x34ab
sarq $0x1d, %r13
movq (%rsp), %rbx
andq $0x0, (%rbx,%r13)
movq %r15, 0x18(%r14)
jmp 0x34ea
movq (%rsp), %rax
andl $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_O2/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 0x43d0
testl %eax, %eax
je 0x361c
leaq 0xc(%rsp), %r14
orl $-0x1, (%r14)
leaq 0x8(%rsp), %r15
orl $-0x1, (%r15)
pushq $-0x1
popq %rax
pushq $0x54
popq %rbp
testl %eax, %eax
je 0x361c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33e0
testq %rax, %rax
je 0x361f
movq %rax, %r12
movq %rbx, %rdi
callq 0x336c
cmpl $0x54, %eax
je 0x361f
cmpl $0x0, 0x40(%rbx)
jne 0x35fe
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax)
je 0x35fe
movq %rbx, %rdi
callq 0x2fa1
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x3566
testl %eax, %eax
jne 0x361c
movq %r12, 0x18(%rbx)
andl $0x0, 0x40(%rbx)
movl 0x8(%rsp), %eax
jmp 0x35b7
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_O2/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 %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x43d0
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x2130
movq %rax, %r14
testq %rax, %rax
je 0x36a8
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq %ebp, %rax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x3696
movq %r15, %rsi
callq 0x43a1
testl %eax, %eax
jne 0x367a
addl $0x2, %ebp
movslq %ebp, %rax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x3696
callq 0x4960
movq %rax, (%r14,%r12,8)
incl %ebp
incq %r12
jmp 0x365f
movl %r12d, %eax
andq $0x0, (%r14,%rax,8)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x436b
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x21e0
cmpl $-0x1, %eax
je 0x36de
testl %eax, %eax
je 0x36ea
leaq 0xc(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x36e1
pushq $0x54
popq %rax
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 0x2150
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x20b0
movq %rbx, %rdi
callq 0x3185
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x3b7f(%rip), %r14      # 0x72ba
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x373b
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x379e
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3b44(%rip), %rsi      # 0x72ba
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x379e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36b4
cmpl $0x54, %eax
je 0x379e
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_O2/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
callq 0x21e0
cmpl $-0x1, %eax
je 0x37d6
testl %eax, %eax
je 0x37e2
leaq 0xc(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x37d9
pushq $0x54
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2150
cmpl $-0x1, %eax
jne 0x3813
leaq 0x3acb(%rip), %rdi      # 0x72c5
leaq 0x386d(%rip), %rdx      # 0x706e
movq %r14, %rsi
xorl %eax, %eax
callq 0x5648
pushq $0x54
popq %rdi
callq 0x21a0
movl %eax, %ebp
movl %eax, %edi
xorl %esi, %esi
callq 0x20b0
movq %rbx, %rdi
callq 0x3185
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x3a68(%rip), %r14      # 0x72b7
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x384f
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x38b2
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3a2d(%rip), %rsi      # 0x72b7
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x38b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37ac
cmpl $0x54, %eax
je 0x38b2
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_O2/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 0x43d0
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2130
testq %rax, %rax
je 0x3947
movq %rax, %r15
leaq 0x39c1(%rip), %r12      # 0x72b5
movq %rbx, %r13
movq (%r13), %rdi
movq %r12, %rsi
callq 0x43a1
addq $0x8, %r13
testl %eax, %eax
jne 0x38f7
xorl %r12d, %r12d
movq %r13, %rbp
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x3935
callq 0x4960
movq %rax, (%r15,%r12,8)
movq (%rbp), %rdi
callq 0x2030
incq %r12
addq $0x8, %rbp
jmp 0x3911
andq $0x0, -0x8(%r13)
movl %r12d, %eax
andq $0x0, (%r15,%rax,8)
movq %r15, (%r14)
jmp 0x3949
xorl %ebx, %ebx
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_O2/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 0x3987
movq 0x18(%rbx), %rax
movq (%rax), %rsi
leaq 0x386b(%rip), %rdi      # 0x71e4
leaq 0x386b(%rip), %rdx      # 0x71eb
xorl %eax, %eax
callq 0x5648
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2efc
testq %rax, %rax
jne 0x399f
movl $0x1, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39bd
xorl %eax, %eax
cmpq $0x0, (%rsi)
jne 0x39d5
leaq 0x3907(%rip), %rdi      # 0x72cb
xorl %eax, %eax
callq 0x5648
movl $0x1, 0x3c(%rbx)
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x54
popq %rbp
cmpl $-0x1, %eax
je 0x3a31
callq 0x21e0
cmpl $-0x1, %eax
je 0x3a31
testl %eax, %eax
je 0x3a3e
movl (%rsp), %edi
callq 0x20d0
movl 0x4(%rsp), %edi
pushq $0x1
popq %rsi
callq 0x20b0
movl 0x4(%rsp), %edi
callq 0x20d0
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
callq 0x3583
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 0x3583
movl 0x3c(%rbx), %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq 0x18(%rdi), %rdi
callq 0x38c0
movq %rax, 0x18(%r14)
pushq $0x54
popq %r12
testq %rax, %rax
je 0x3b0c
movq %rax, %rbx
movl $0x1, 0x40(%r14)
movq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x39a7
cmpl $-0x1, %eax
je 0x3b08
callq 0x21e0
cmpl $-0x1, %eax
je 0x3b0c
testl %eax, %eax
je 0x3b1b
leaq 0x14(%rsp), %r12
pushq $0x2
popq %rdx
movl %eax, %edi
movq %r12, %rsi
callq 0x2140
movzbl 0x1(%r12), %eax
movl %eax, 0x3c(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x395b
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rsi
callq 0x436b
xorl %edi, %edi
movq %rbx, %rsi
callq 0x436b
jmp 0x3b0c
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x39d7
movl %eax, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x21e0
cmpl $-0x1, %eax
je 0x3b65
testl %eax, %eax
je 0x3b71
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
movzbl 0x1(%r14), %eax
movl %eax, 0x3c(%rbx)
xorl %eax, %eax
jmp 0x3b68
pushq $0x54
popq %rax
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 0x2150
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x3ba0
pushq $0x42
popq %rsi
movq %r14, %rdi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2150
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %ebp, %edi
callq 0x20b0
movq %rbx, %rdi
callq 0x2fa1
movl %ebp, %edi
callq 0x20d0
movl 0x3c(%rbx), %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x36e1(%rip), %r14      # 0x72bd
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x3bdc
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x3c3f
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x36a6(%rip), %rsi      # 0x72bd
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3c3f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b30
cmpl $0x54, %eax
je 0x3c3f
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_O2/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 0x35d0(%rip), %r14      # 0x72bc
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x3cec
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x3d4f
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3595(%rip), %rsi      # 0x72bc
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3d4f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c4c
cmpl $0x54, %eax
je 0x3d4f
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_O2/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 0x43d0
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2130
movq %rax, %r14
testq %rax, %rax
je 0x3da0
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x3d9b
callq 0x4960
movq %rax, (%r14,%r15)
addq $0x8, %r15
jmp 0x3d83
andq $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r15
cmpq $0x0, 0x8(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x3db9
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x3e00
leaq -0x1(%r15), %r13
movq (%rbx,%r12,8), %rdi
callq 0x4960
movq %rax, %r14
movq -0x8(%rbx,%r15,8), %rdi
callq 0x4960
movq %rax, (%rbx,%r12,8)
movq %r14, %rdi
callq 0x4960
movq %rax, -0x8(%rbx,%r15,8)
incq %r12
movq %r13, %r15
jmp 0x3dc8
movq %r14, %rdi
callq 0x2030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
movq 0x18(%rdi), %rdi
callq 0x3d5c
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x3472(%rip), %r15      # 0x72b1
movq 0x18(%rbx), %rdi
callq 0x43d0
cmpl $0x1, %eax
je 0x3f0a
movq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x43d0
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2130
movq %rax, %r12
testq %rax, %rax
je 0x3f06
movq %rbp, (%rsp)
xorl %ebp, %ebp
movq (%r13,%rbp), %rdi
movq %r15, %rsi
callq 0x43a1
testl %eax, %eax
je 0x3ea3
movq (%r13,%rbp), %rdi
callq 0x4960
movq %rax, (%r12,%rbp)
addq $0x8, %rbp
jmp 0x3e7e
andq $0x0, (%r12,%rbp)
movq %r14, %rdi
callq 0x3da9
pushq $-0x1
popq %rax
movq %rax, %r13
incq %rax
cmpq $0x0, 0x8(%r14,%r13,8)
jne 0x3eb3
movq %r13, %rbp
movq (%r14,%r13,8), %rdi
movq %r15, %rsi
callq 0x43a1
addq $-0x1, %rbp
jae 0x3ee8
testl %eax, %eax
je 0x3ee8
movq (%r14,%r13,8), %rdi
callq 0x2030
movq %rbp, %r13
jmp 0x3ec4
andq $0x0, (%r14,%r13,8)
movq %r14, %rdi
callq 0x43d0
cmpl $0x1, %eax
movq (%rsp), %rbp
je 0x3f06
movq %r14, %rdi
callq 0x3da9
movq %r12, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2fa1
cmpl $0x1, 0x3c(%rbx)
sete %al
orb %al, %bpl
testb $0x1, %bpl
jne 0x3f3a
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x43d0
cmpl $0x1, %eax
sete %bpl
jmp 0x3e3f
xorl %edi, %edi
movq %r14, %rsi
callq 0x436b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x40(%rdi)
movq 0x18(%rdi), %rdi
callq 0x3d5c
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x3332(%rip), %r15      # 0x72b4
movq 0x18(%rbx), %rdi
callq 0x43d0
cmpl $0x1, %eax
je 0x4053
movq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x43d0
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2130
movq %rax, %r12
testq %rax, %rax
je 0x404f
movq %rbp, (%rsp)
xorl %ebp, %ebp
movq (%r13,%rbp), %rdi
movq %r15, %rsi
callq 0x43a1
testl %eax, %eax
je 0x3fe6
movq (%r13,%rbp), %rdi
callq 0x4960
movq %rax, (%r12,%rbp)
addq $0x8, %rbp
jmp 0x3fc1
andq $0x0, (%r12,%rbp)
movq %r14, %rdi
callq 0x3da9
movq %rax, %r14
pushq $-0x1
popq %rax
movq %rax, %r13
incq %rax
cmpq $0x0, 0x8(%r14,%r13,8)
jne 0x3ff9
movq %r13, %rbp
movq (%r14,%r13,8), %rdi
movq %r15, %rsi
callq 0x43a1
addq $-0x1, %rbp
jae 0x402e
testl %eax, %eax
je 0x402e
movq (%r14,%r13,8), %rdi
callq 0x2030
movq %rbp, %r13
jmp 0x400a
andq $0x0, (%r14,%r13,8)
movq %r14, %rdi
callq 0x43d0
cmpl $0x1, %eax
je 0x404b
movq %r14, %rdi
callq 0x3da9
movq %rax, %r14
movq (%rsp), %rbp
movq %r12, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2fa1
cmpl $0x0, 0x3c(%rbx)
sete %al
orb %al, %bpl
testb $0x1, %bpl
jne 0x4083
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x43d0
cmpl $0x1, %eax
sete %bpl
jmp 0x3f82
xorl %edi, %edi
movq %r14, %rsi
callq 0x436b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaxenceEpitech[P]42sh/flags/redi_all.c
// Function: all_redi
int		all_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);
      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
callq 0x21e0
cmpl $-0x1, %eax
je 0x40ca
testl %eax, %eax
je 0x40d6
leaq 0xc(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x40cd
pushq $0x54
popq %rax
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 0x2150
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x20b0
pushq $0x2
popq %rsi
movl %ebp, %edi
callq 0x20b0
movq %rbx, %rdi
callq 0x3185
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x318f(%rip), %r14      # 0x72c0
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x4131
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x4194
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3154(%rip), %rsi      # 0x72c0
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x4194
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40a0
cmpl $0x54, %eax
je 0x4194
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_O2/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
callq 0x21e0
cmpl $-0x1, %eax
je 0x41cb
testl %eax, %eax
je 0x41d7
leaq 0xc(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x41ce
pushq $0x54
popq %rax
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 0x2150
movl %eax, %ebp
pushq $0x2
popq %rsi
movl %eax, %edi
callq 0x20b0
movq %rbx, %rdi
callq 0x3185
movl %ebp, %edi
callq 0x20d0
xorl %edi, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 0x3091(%rip), %r14      # 0x72b9
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x43a1
addq $0x8, %r15
testl %eax, %eax
jne 0x4228
movq 0x18(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x4960
pushq $0x54
popq %rbp
testq %rax, %rax
je 0x428b
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3056(%rip), %rsi      # 0x72b9
callq 0x3630
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x428b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41a1
cmpl $0x54, %eax
je 0x428b
movq %r14, %rdi
callq 0x2030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq