LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/function.c
// Function: my_strcmp
int		my_strcmp(char *s1, char *s2)
{
  int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x58d1
cmpq $0x0, -0x18(%rbp)
jne 0x58dd
movl $0x1, -0x4(%rbp)
jmp 0x596b
jmp 0x58df
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x592b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x592b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x5934
jmp 0x593f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x58df
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x5964
movl $0x1, -0x4(%rbp)
jmp 0x596b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/function.c
// Function: my_tablen
int		my_tablen(char **tab)
{
  int		i;

  i = 0;
  if (tab == NULL)
    return (-1);
  while (tab[i] != NULL)
    i += 1;
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x598f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x59b1
jmp 0x5991
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x59ab
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5991
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/function_two.c
// Function: my_count
int		my_count(char *str, char sep)
{
  int		i;
  int		j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5a15
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5a0a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x59dc
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/function_two.c
// Function: init_struct
void		init_struct(t_info_shell *shell)
{
  shell->exit_value = 0;
  shell->alias_value = 0;
  if ((shell->historic = malloc(sizeof(char *) * 1)) == NULL)
    return ;
  shell->historic[0] = NULL;
  shell->path_save = get_path(environ, "PATH");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movl $0x8, %edi
callq 0x2130
movq -0x8(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x5a9c
jmp 0x5acc
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, (%rax)
movq 0x6536(%rip), %rax      # 0xbfe8
movq (%rax), %rdi
leaq 0x3677(%rip), %rsi      # 0x9133
callq 0x5ea0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/function_two.c
// Function: free_struct
void		free_struct(t_info_shell *shell)
{
  free_all(shell->command, shell->tab);
  free_all(shell->mem, shell->tab_mem);
  free_all(shell->path_save, shell->historic);
  free_all(NULL, shell->alias_tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x5850
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5850
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x5850
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x5850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_epurstr.c
// Function: little_verif
char	*little_verif(char *str)
{
  int	i;

  i = 0;
  if (str == NULL)
    return (NULL);
  while (str[i] != '\0')
    i += 1;
  if (str[i - 1] == ';')
    str[i - 1] = '\0';
  return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5b70
movq $0x0, -0x8(%rbp)
jmp 0x5bbd
jmp 0x5b72
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5b8e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b72
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x5bb5
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_epurstr.c
// Function: my_epurstr
char	*my_epurstr(char *str)
{
  int	i;
  int	x;
  char	*str2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5c14
movq -0x10(%rbp), %rdi
callq 0x5820
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5c21
movq $0x0, -0x8(%rbp)
jmp 0x5d7a
jmp 0x5c23
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5cfc
jmp 0x5c3a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x5c61
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x21(%rbp)
jne 0x5c9c
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x22(%rbp)
je 0x5c96
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5ca5
jmp 0x5cb0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5c3a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x5ccd
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x5c23
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x5d34
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x5d45
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x5d5d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x5d69
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_path.c
// Function: search_path
int		search_path(char **my_env, char *key)
{
  t_count	ct;
  char		*mem;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5e90
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5820
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5dfb
movl $0x54, -0x4(%rbp)
jmp 0x5e97
jmp 0x5dfd
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x5e4a
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x5dfd
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x58b0
cmpl $0x0, %eax
jne 0x5e79
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5e97
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5da7
movl $0x54, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_path.c
// Function: get_path
char		*get_path(char **my_env, char *key)
{
  int		i;
  int		j;
  int		k;
  char		*tmp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d90
movl %eax, -0x1c(%rbp)
cmpl $0x54, -0x1c(%rbp)
jne 0x5ed3
movq $0x0, -0x8(%rbp)
jmp 0x5fa7
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
callq 0x5820
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5f19
movq $0x0, -0x8(%rbp)
jmp 0x5fa7
jmp 0x5f1b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x5f44
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5f1b
jmp 0x5f46
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5f93
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x5f46
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/get_next_line.c
// Function: get_next_line
char		*get_next_line(const int fd)
{
  static int	size = 1;
  static char	*mem = NULL;
  char		buff[READ_SIZE + 1];
  char		*line;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x6274(%rip)      # 0xc250
movb %al, -0x19(%rbp)
je 0x5ff8
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x60c0
cmpl $-0x1, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6001
jmp 0x6061
movl -0xc(%rbp), %edi
leaq -0xe(%rbp), %rsi
movl $0x1, %edx
callq 0x2100
movl %eax, 0x6238(%rip)      # 0xc250
cmpl $-0x1, %eax
jne 0x602a
movq $0x0, -0x8(%rbp)
jmp 0x60ae
movslq 0x621f(%rip), %rax      # 0xc250
movb $0x0, -0xe(%rbp,%rax)
movq -0x18(%rbp), %rdi
leaq -0xe(%rbp), %rsi
movl $0x1, %edx
callq 0x68d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x605c
movq $0x0, -0x8(%rbp)
jmp 0x60ae
jmp 0x5fd3
movq -0x18(%rbp), %rdi
leaq 0x641c(%rip), %rsi      # 0xc488
callq 0x6130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x6085
movq $0x0, -0x8(%rbp)
jmp 0x60ae
movq -0x18(%rbp), %rdi
callq 0x5820
cmpl $0x0, %eax
jne 0x60a6
cmpl $0x0, 0x61b6(%rip)      # 0xc250
jne 0x60a6
movq $0x0, -0x8(%rbp)
jmp 0x60ae
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/get_next_line.c
// Function: my_str_contain
static int	my_str_contain(char *str, char rep)
{
  size_t	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x611d
jmp 0x60df
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x611b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x610d
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x6124
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x60df
jmp 0x611d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/get_next_line.c
// Function: get_line
static char		*get_line(char *line, char **mem)
{
  char			*tmp;

  if (line[0] == '\0')
    return (NULL);
  if (*mem != NULL)
    {
      if ((line = my_strcat(*mem, line, 0)) == NULL)
  	return (NULL);
      *mem = NULL;
    }
  line[my_str_contain(line, '\n')] = '\0';
  tmp = line + my_strlen(line) + 1;
  if (my_strlen(tmp) == 0)
    tmp = NULL;
  if ((*mem = my_strcat(NULL, tmp, 2)) == NULL)
    return (NULL);
  return (line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6159
movq $0x0, -0x8(%rbp)
jmp 0x6226
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6197
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x68d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x618c
movq $0x0, -0x8(%rbp)
jmp 0x6226
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x60c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5820
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5820
cmpl $0x0, %eax
jne 0x61f5
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %edx
callq 0x68d0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x621e
movq $0x0, -0x8(%rbp)
jmp 0x6226
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_str_to_wordtab.c
// Function: count_words
int		count_words(const char *str, char sep)
{
  int		words;
  int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6269
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x624c
jmp 0x626b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x62d6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x62ba
jmp 0x6292
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x62b1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6292
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x62d4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x626b
cmpl $0x0, -0x14(%rbp)
je 0x62fe
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x62fe
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_str_to_wordtab.c
// Function: alloc_line
char		*alloc_line(const char *str, char sep, int *i)
{
  char		*line;
  int		tmp;
  int		len;

  tmp = *i;
  len = 0;
  while (str[*i] != '\0' && str[*i] != sep)
    {
      *i = *i + 1;
      len = len + 1;
    }
  if ((line = malloc(sizeof(char) * (len + 1))) == NULL)
    return (NULL);
  len = 0;
  while (tmp < *i)
    line[len++] = str[tmp++];
  line[len] = '\0';
  if (str[*i] != '\0')
    *i = *i + 1;
  return (line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x636a
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6373
jmp 0x638d
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6336
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x63b3
movq $0x0, -0x8(%rbp)
jmp 0x6428
movl $0x0, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x63f1
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x30(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x63ba
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6420
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_str_to_wordtab.c
// Function: my_str_to_wordtab
char		**my_str_to_wordtab(const char *str, char sep)
{
  char		**tab;
  int		words;
  int		i;
  int		j;

  i = 0;
  j = 0;
  if (str == NULL)
    return (NULL);
  words = count_words(str, sep);
  if ((tab = malloc(sizeof(char *) * (words + 1))) == NULL)
    return (NULL);
  while (i < words)
    {
      while (str[j] == sep)
	j = j + 1;
      if ((tab[i] = alloc_line(str, sep, &j)) == NULL)
	return (NULL);
      i = i + 1;
    }
  tab[i] = NULL;
  return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6474
movq $0x0, -0x8(%rbp)
jmp 0x6525
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x6230
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x64aa
movq $0x0, -0x8(%rbp)
jmp 0x6525
jmp 0x64ac
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x650d
jmp 0x64b6
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x64d5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x64b6
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
movsbl -0x11(%rbp), %esi
callq 0x6310
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x6502
movq $0x0, -0x8(%rbp)
jmp 0x6525
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x64ac
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_str_isalpha.c
// Function: my_str_isalpha
int		my_str_isalpha(char *str)
{
  int		i;

  i = 0;
  while (str[i] != '\0')
    {
      if ((str[i] < '0' || str[i] > '9')
	  && (str[i] < 'A' || str[i] > 'Z')
	  && (str[i] < 'a' || str[i] > 'z'))
	return (1);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x65cd
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x6572
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x65bf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x6594
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jle 0x65bf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x65b6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jle 0x65bf
movl $0x1, -0x4(%rbp)
jmp 0x65d4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x653f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_strdup.c
// Function: my_strdup
char	*my_strdup(char *src)
{
  int	i;
  char	*copy;

  i = 0;
  if (src == NULL)
    return (NULL);
  if ((copy = malloc(sizeof(char) * (my_strlen(src) + 1))) == NULL)
    return (NULL);
  while (src[i] != '\0')
    {
      copy[i] = src[i];
      i = i + 1;
    }
  copy[i] = '\0';
  return (copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6654
movq $0x0, -0x8(%rbp)
jmp 0x66c8
movq -0x10(%rbp), %rdi
callq 0x5820
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x6680
movq $0x0, -0x8(%rbp)
jmp 0x66c8
jmp 0x6682
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x66b4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6682
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/read_file.c
// Function: read_file
char		*read_file(char *path)
{
  char		*my_file;
  int		fd;
  char		buffer[2];

  buffer[1] = '\0';
  my_file = NULL;
  if ((fd = open(path, O_RDONLY)) == -1)
    {
      my_printf("%s: %s", path, NO_SUCH_FILE);
      return (NULL);
    }
  while (read(fd, buffer, 1) != 0)
    my_file = my_strcat(my_file, buffer, 1);
  close(fd);
  return (my_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x1d(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x6730
movq -0x10(%rbp), %rsi
leaq 0x2acc(%rip), %rdi      # 0x91e4
leaq 0x294f(%rip), %rdx      # 0x906e
movb $0x0, %al
callq 0x7ed1
movq $0x0, -0x8(%rbp)
jmp 0x6771
jmp 0x6732
movl -0x1c(%rbp), %edi
leaq -0x1e(%rbp), %rsi
movl $0x1, %edx
callq 0x2100
cmpq $0x0, %rax
je 0x6761
movq -0x18(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
movl $0x1, %edx
callq 0x68d0
movq %rax, -0x18(%rbp)
jmp 0x6732
movl -0x1c(%rbp), %edi
callq 0x20d0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/command_verif.c
// Function: pipe_verif
int		pipe_verif(t_info_shell *shell)
{
  int		i;
  char		*command;

  i = 0;
  command = shell->command;
  while (command[i] != '\0')
    {
      if (command[i] != '|')
        return (0);
      i += 1;
    }
  my_printf("%s", INVALID_NULL);
  shell->exit_value = 1;
  return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x67d4
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
je 0x67c9
movl $0x0, -0x4(%rbp)
jmp 0x67fb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x679e
leaq 0x2a0d(%rip), %rdi      # 0x91e8
leaq 0x2ae9(%rip), %rsi      # 0x92cb
movb $0x0, %al
callq 0x7ed1
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/command_verif.c
// Function: command_verif
int		command_verif(t_info_shell *shell)
{
  int		i;
  char		*command;

  i = 0;
  command = shell->command;
  if ((my_strlen(command) == 0) || (pipe_verif(shell) == 1))
    {
      free(command);
      return (1);
    }
  while (command[i] != '\0')
    {
      if (command[i] != ' ' && command[i] != '\t' && command[i] != ';')
        return (0);
      i += 1;
    }
  free(command);
  return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5820
cmpl $0x0, %eax
je 0x684a
movq -0x10(%rbp), %rdi
callq 0x6780
cmpl $0x1, %eax
jne 0x685c
movq -0x20(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0x68c6
jmp 0x685e
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x68b6
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x68ab
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x68ab
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
je 0x68ab
movl $0x0, -0x4(%rbp)
jmp 0x68c6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x685e
movq -0x20(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_strcat.c
// Function: my_strcat
char		*my_strcat(char *dest, char *src, int bhv)
{
  size_t	i;
  size_t	j;
  char		*new;

  i = (dest != NULL) ? my_strlen(dest) : 0;
  j = (src != NULL) ? my_strlen(src) : 0;
  if ((new = malloc(sizeof(char) * (i + j + 1))) == NULL)
    return (NULL);
  i = 0;
  j = 0;
  if (dest != NULL)
    while (dest[i] != '\0')
      {
        new[i] = dest[i];
        i += 1;
      }
  new[i] = '\0';
  if (src != NULL)
    while (src[j] != '\0')
      new[i++] = src[j++];
  new[i] = '\0';
  if (bhv == 2)
    return (new);
  (bhv == 0) ? (free(dest), free(src)) : (free(dest));
  return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x68f8
movq -0x10(%rbp), %rdi
callq 0x5820
movl %eax, -0x3c(%rbp)
jmp 0x68ff
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x68ff
movl -0x3c(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x691d
movq -0x18(%rbp), %rdi
callq 0x5820
movl %eax, -0x40(%rbp)
jmp 0x6924
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x6924
movl -0x40(%rbp), %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x6959
movq $0x0, -0x8(%rbp)
jmp 0x6a46
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x69a9
jmp 0x6972
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x69a7
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6972
jmp 0x69a9
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
je 0x69ff
jmp 0x69be
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x69fd
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x69be
jmp 0x69ff
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x2, -0x1c(%rbp)
jne 0x6a1b
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a46
cmpl $0x0, -0x1c(%rbp)
jne 0x6a35
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x6a3e
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/command_normed.c
// Function: command_normed
char		*command_normed(char *command, char sep)
{
  int		i;
  int		j;
  char		*str;

  if ((str = malloc(sizeof(char) * my_strlen(command)
                    + my_count(command, sep) + 1)) == NULL)
    return (NULL);
  i = -1;
  j = 0;
  while (command[++i] != '\0')
    {
      if ((command[i] == sep) && i != 0 &&(command[i - 1] != ' '))
        str[j++] = ' ';
      str[j] = command[i];
      if ((command[i] == sep) && (command[i + 1] != ' ') && command[i + 1] != 0)
        str[j++ + 1] = ' ';
      j += 1;
    }
  str[j] = '\0';
  if ((str = clean_pipes(str, '|')) == NULL)
    return (NULL);
  if ((str = clean_pipes(str, '&')) == NULL)
    return (NULL);
  return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5820
cltq
shlq $0x0, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x59c0
movq -0x30(%rbp), %rdi
cltq
addq %rax, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6aab
movq $0x0, -0x8(%rbp)
jmp 0x6bf1
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6b99
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6b1c
cmpl $0x0, -0x18(%rbp)
je 0x6b1c
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x6b1c
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6b8b
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x6b8b
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6b8b
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ab9
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
movl $0x7c, %esi
callq 0x7960
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6bc7
movq $0x0, -0x8(%rbp)
jmp 0x6bf1
movq -0x28(%rbp), %rdi
movl $0x26, %esi
callq 0x7960
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6be9
movq $0x0, -0x8(%rbp)
jmp 0x6bf1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/tab/tabulation.c
// Function: sort_dir
char		**sort_dir(char *command)
{
  int		i;
  int		j;
  int		size;
  char		**dir;
  char		**new_tab;

  i = 0;
  size = 0;
  j = 0;
  if (((dir = my_ls(".", &size)) == NULL)
      || ((new_tab = malloc(sizeof(char *) * size + 1)) == NULL))
    return (NULL);
  while (dir[i] != NULL)
    {
      if (my_find_str(dir[i], command) == 1)
	new_tab[j++] = my_strdup(dir[i]);
      i += 1;
    }
  new_tab[j] = NULL;
  free_all(NULL, dir);
  return (new_tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
leaq 0x2427(%rip), %rdi      # 0x904f
leaq -0x1c(%rbp), %rsi
callq 0x6e40
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6c56
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x6c63
movq $0x0, -0x8(%rbp)
jmp 0x6ce8
jmp 0x6c65
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6cc3
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x5790
cmpl $0x1, %eax
jne 0x6cb8
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6630
movq %rax, %rdx
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c65
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x5850
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/tab/tabulation.c
// Function: tabulation
void		tabulation(char *command)
{
  char		**tab;
  int		i;

  i = 0;
  tab = sort_dir(command);
  if (my_tablen(tab) == 1)
    {
      while (command[i] == *tab[i])
	i += 1;
      while (*tab[i] != '\0')
	{
	  write(0, &(*tab[i]), 1);
	  i += 1;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6c00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5970
cmpl $0x1, %eax
jne 0x6d95
jmp 0x6d30
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6d5a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d30
jmp 0x6d5c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6d93
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x1, %edx
callq 0x2070
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d5c
jmp 0x6d95
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/tab/my_ls.c
// Function: dir_len
int		dir_len(char *path, int nb)
{
  struct dirent *ptr;
  int		i;
  DIR		*dir;

  i = 0;
  if (((dir = opendir(path)) == NULL) || ((ptr = readdir(dir)) == NULL))
    return (84);
  while (ptr != NULL)
    {
      if (nb != 0)
	{
	  if ((ptr->d_name)[0] != '.')
	    i += 1;
	}
      else if (nb == 0)
	i += 1;
      ptr = readdir(dir);
    }
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2080
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6ddc
movq -0x30(%rbp), %rdi
callq 0x2120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x6de5
movl $0x54, -0x4(%rbp)
jmp 0x6e32
jmp 0x6de7
cmpq $0x0, -0x20(%rbp)
je 0x6e2c
cmpl $0x0, -0x14(%rbp)
je 0x6e0c
movq -0x20(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
je 0x6e0a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e1d
cmpl $0x0, -0x14(%rbp)
jne 0x6e1b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e1d
movq -0x30(%rbp), %rdi
callq 0x2120
movq %rax, -0x20(%rbp)
jmp 0x6de7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/tab/my_ls.c
// Function: my_ls
char		**my_ls(char *path, int *size)
{
  struct dirent *ptr;
  int		i;
  DIR		*dir;
  char		**tab;
  int		len;

  i = 0;
  if ((len = dir_len(path, 0) + 1) == 84)
    return (NULL);
  *size = len;
  if ((tab = malloc(sizeof(char *) * len + 1)) == NULL)
    return (NULL);
  if (((dir = opendir(path)) == NULL) || ((ptr = readdir(dir)) == NULL))
    return (NULL);
  while (ptr != NULL)
    {
      tab[i++] = my_strdup(ptr->d_name);
      ptr = readdir(dir);
    }
  closedir(dir);
  tab[i] = NULL;
  return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6da0
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x54, %eax
jne 0x6e7a
movq $0x0, -0x8(%rbp)
jmp 0x6f3a
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movslq -0x3c(%rbp), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x6eab
movq $0x0, -0x8(%rbp)
jmp 0x6f3a
movq -0x10(%rbp), %rdi
callq 0x2080
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6ed1
movq -0x30(%rbp), %rdi
callq 0x2120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x6edb
movq $0x0, -0x8(%rbp)
jmp 0x6f3a
jmp 0x6edd
cmpq $0x0, -0x20(%rbp)
je 0x6f19
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
callq 0x6630
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdi
callq 0x2120
movq %rax, -0x20(%rbp)
jmp 0x6edd
movq -0x30(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/repeat.c
// Function: my_strisnum
int		my_strisnum(char *str)
{
  int		i;

  i = 0;
  while (str[i] != '\0')
    {
      if (str[i] < '0' || str[i] > '9')
	return (1);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6fa6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x6f92
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x6f9b
movl $0x1, -0x4(%rbp)
jmp 0x6fad
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6f5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/repeat.c
// Function: repeat_check
int		repeat_check(t_info_shell *shell)
{
  int		i;

  i = my_tablen(shell->tab);
  if ((i == 1) || (i == 2))
    {
      my_printf("repeat: Too few arguments.\n");
      shell->exit_value = 1;
      return (84);
    }
  if (my_strcmp("repeat", shell->tab[0]) != 0)
    return (84);
  if (my_strisnum(shell->tab[1]) != 0)
    {
      my_printf("repeat: Badly formed number.\n");
      shell->exit_value = 1;
      return (84);
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5970
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x6fe8
cmpl $0x2, -0x14(%rbp)
jne 0x700a
leaq 0x22f3(%rip), %rdi      # 0x92e2
movb $0x0, %al
callq 0x7ed1
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movl $0x54, -0x4(%rbp)
jmp 0x706e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
leaq 0x21b3(%rip), %rdi      # 0x91cf
callq 0x58b0
cmpl $0x0, %eax
je 0x702f
movl $0x54, -0x4(%rbp)
jmp 0x706e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x6f50
cmpl $0x0, %eax
je 0x7067
leaq 0x22b2(%rip), %rdi      # 0x92fe
movb $0x0, %al
callq 0x7ed1
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movl $0x54, -0x4(%rbp)
jmp 0x706e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/repeat.c
// Function: cut_my_string
char		*cut_my_string(char *command)
{
  int		i;
  int		j;
  char		*new_command;

  new_command = malloc(sizeof(char) * my_strlen(command) + 1);
  i = 7;
  j = 0;
  while (command[i] != ' ')
    i += 1;
  while (command[i] != '\0')
    {
      new_command[j] = command[i];
      i += 1;
      j += 1;
    }
  new_command[j] = '\0';
  return (new_command);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5820
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
movl $0x7, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x70d3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x70b7
jmp 0x70d5
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7110
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x70d5
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/repeat.c
// Function: repeat
int		repeat(t_info_shell *shell)
{
  int		i;
  int		nb;
  char		**save_tab;
  char		*save_string;

  i = 0;
  if ((repeat_check(shell)) != 0)
    return (84);
  nb = atoi(shell->tab[1]);
  if ((nb == 0) || (nb < 0))
    return (0);
  save_tab = cut_my_tab(shell->tab);
  save_string = cut_my_string(shell->command);
  while (i < nb)
    {
      shell->command = save_string;
      shell->tab = save_tab;
      execution_in_chain(shell);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6fc0
cmpl $0x0, %eax
je 0x715d
movl $0x54, -0x4(%rbp)
jmp 0x71e1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x717d
cmpl $0x0, -0x18(%rbp)
jge 0x7186
movl $0x0, -0x4(%rbp)
jmp 0x71e1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x71f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7080
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x71da
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x3b80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x71a7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/repeat.c
// Function: cut_my_tab
static char	**cut_my_tab(char **shell_tab)
{
  int		i;
  int		j;
  char		**tab;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5970
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7233
movq $0x0, -0x8(%rbp)
jmp 0x7290
jmp 0x7235
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7278
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6630
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7235
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)