LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/which.c
// Function: which_verif
int		which_verif(t_info_shell *shell)
{
  if (my_tablen(shell->tab) == 1)
    {
      shell->exit_value = 1;
      my_printf("which: Too few arguments.\n");
      return (84);
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5970
cmpl $0x1, %eax
jne 0x72e0
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
leaq 0x204c(%rip), %rdi      # 0x931c
movb $0x0, %al
callq 0x7ed1
movl $0x54, -0x4(%rbp)
jmp 0x72e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/which.c
// Function: verif_path
void		verif_path(t_info_shell *shell, int ptr)
{
  char		*path;

  if (my_strcmp(shell->tab[0], "echo") == 0)
    {
      my_printf("echo: shell built-in command.\n");
      ptr = 1;
    }
  if (ptr == 0)
    {
      if ((path = is_valid_command(shell)) != NULL)
	my_printf("%s\n", path);
      else
	{
	  my_printf("%s: %s", shell->tab[0], COMMAND_ERROR);
	  shell->exit_value = 1;
	}
    }
  ptr = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x2026(%rip), %rsi      # 0x9337
callq 0x58b0
cmpl $0x0, %eax
jne 0x7330
leaq 0x201a(%rip), %rdi      # 0x933c
movb $0x0, %al
callq 0x7ed1
movl $0x1, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x738a
movq -0x8(%rbp), %rdi
callq 0x36d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x735d
movq -0x18(%rbp), %rsi
leaq 0x205b(%rip), %rdi      # 0x93af
movb $0x0, %al
callq 0x7ed1
jmp 0x7388
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
leaq 0x1e75(%rip), %rdi      # 0x91e4
leaq 0x1e75(%rip), %rdx      # 0x91eb
movb $0x0, %al
callq 0x7ed1
movq -0x8(%rbp), %rax
movl $0x1, 0x3c(%rax)
jmp 0x738a
movl $0x0, -0xc(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/which.c
// Function: which
int		which(t_info_shell *shell)
{
  int		i;
  int		ptr;

  ptr = 0;
  if ((which_verif(shell)) != 0)
    return (84);
  while (1)
    {
      i = 0;
      if ((shell->tab = cut_my_tab(shell)) == NULL)
	break ;
      while (i < 10)
	{
	  if (my_strcmp(shell->tab[0], g_key[i].code) == 0)
	    {
	      my_printf("%s: shell built-in comand.\n", g_key[i].code);
	      ptr = 1;
	    }
	  i += 1;
	}
      verif_path(shell, ptr);
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x72a0
cmpl $0x0, %eax
je 0x73cd
movl $0x54, -0x4(%rbp)
jmp 0x746e
jmp 0x73cf
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7480
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x73ef
jmp 0x7467
jmp 0x73f1
cmpl $0xa, -0x14(%rbp)
jge 0x7456
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x4e53(%rip), %rax      # 0xc260
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x58b0
cmpl $0x0, %eax
jne 0x744b
movslq -0x14(%rbp), %rcx
leaq 0x4e34(%rip), %rax      # 0xc260
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x1f1e(%rip), %rdi      # 0x935b
movb $0x0, %al
callq 0x7ed1
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x73f1
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x72f0
jmp 0x73cf
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/which.c
// Function: cut_my_tab
static char	**cut_my_tab(t_info_shell *shell)
{
  char		**new_tab;
  int		i;
  int		j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5970
movslq %eax, %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x74c0
movq $0x0, -0x8(%rbp)
jmp 0x754e
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x74e4
movq $0x0, -0x8(%rbp)
jmp 0x754e
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7536
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6630
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x74eb
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
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/command_bonus/where.c
// Function: where_verif
int		where_verif(t_info_shell *shell)
{
  if (my_tablen(shell->tab) == 1)
    {
      shell->exit_value = 1;
      my_printf("where: Too few arguments.\n");
      return (84);
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5970
cmpl $0x1, %eax
jne 0x75a0
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
leaq 0x1de7(%rip), %rdi      # 0x9377
movb $0x0, %al
callq 0x7ed1
movl $0x54, -0x4(%rbp)
jmp 0x75a7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/where.c
// Function: where
int		where(t_info_shell *shell)
{
  int		i;
  char		*path;

  if ((where_verif(shell)) != 0)
    return (84);
  while (1)
    {
      i = 0;
      if ((shell->tab = cut_my_tab(shell)) == NULL)
	break ;
      while (i < 10)
	{
	  if (my_strcmp(shell->tab[0], g_key[i].code) == 0)
	    my_printf("%s: shell built-in comand.\n", g_key[i].code);
	  i += 1;
	}
      if (my_strcmp(shell->tab[0], "echo") == 0)
	my_printf("echo is a shell built-in\n");
      if ((path = is_valid_command(shell)) != NULL)
	my_printf("%s\n%s\n", path, cut_string(path));
      else
	shell->exit_value = 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7560
cmpl $0x0, %eax
je 0x75d6
movl $0x54, -0x4(%rbp)
jmp 0x76d7
jmp 0x75d8
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76e0
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x75fb
jmp 0x76d0
jmp 0x75fd
cmpl $0xa, -0x14(%rbp)
jge 0x765b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x4ce7(%rip), %rax      # 0xc300
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x58b0
cmpl $0x0, %eax
jne 0x7650
movslq -0x14(%rbp), %rcx
leaq 0x4cc8(%rip), %rax      # 0xc300
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x1d12(%rip), %rdi      # 0x935b
movb $0x0, %al
callq 0x7ed1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x75fd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x1cca(%rip), %rsi      # 0x9337
callq 0x58b0
cmpl $0x0, %eax
jne 0x7685
leaq 0x1d14(%rip), %rdi      # 0x9392
movb $0x0, %al
callq 0x7ed1
movq -0x10(%rbp), %rdi
callq 0x36d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x76c0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x77c0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x1cf5(%rip), %rdi      # 0x93ac
movb $0x0, %al
callq 0x7ed1
jmp 0x76cb
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
jmp 0x75d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/command_bonus/where.c
// Function: cut_string
static char	*cut_string(char *path)
{
  int		i;
  int		j;
  char		*new;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5820
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7803
movq $0x0, -0x8(%rbp)
jmp 0x7872
jmp 0x7805
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x7821
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7805
jmp 0x7823
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x785e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7823
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaxenceEpitech[P]42sh/src/my_clean_pipes.c
// Function: add_a_space
char	*add_a_space(char *str, int pos)
{
  char	*new_str;
  int	i;

  i = 0;
  if ((new_str = malloc(sizeof(char)
			* (my_strlen(str) + 2))) == NULL)
    return (NULL);
  while (i != pos)
    {
      new_str[i] = str[i];
      i++;
    }
  new_str[i] = ' ';
  while (str[i] != 0)
    {
      new_str[i + 1] = str[i];
      i++;
    }
  new_str[i + 1] = 0;
  free(str);
  return (new_str);
}

// 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 0x5820
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x78c5
movq $0x0, -0x8(%rbp)
jmp 0x7955
jmp 0x78c7
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x78f0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x78c7
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7933
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x78fc
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x2030
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_clean_pipes.c
// Function: clean_pipes
char	*clean_pipes(char *str, char c)
{
  int	i;

  i = 0;
  while (str[i + 1] != 0)
    {
      if ((str[i] == c && str[i + 1] != c && str[i + 1] != ' '))
	if ((str = add_a_space(str, i + 1)) == NULL)
	  return (NULL);
      if ((i > 0 && str[i] == c && str[i - 1] != c && str[i - 1] != ' '))
	if ((str = add_a_space(str, i)) == NULL)
	  return (NULL);
      i++;
    }
  if ((str[i] == '|' && str[i + 1] == 0))
    if ((str = add_a_space(str, i)) == NULL)
      return (NULL);
  return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7a77
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x79fe
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x79fe
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x79fe
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0x7880
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x79fc
movq $0x0, -0x8(%rbp)
jmp 0x7ac8
jmp 0x79fe
cmpl $0x0, -0x18(%rbp)
jle 0x7a69
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7a69
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x7a69
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x7a69
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7880
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x7a67
movq $0x0, -0x8(%rbp)
jmp 0x7ac8
jmp 0x7a69
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7979
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
jne 0x7ac0
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x7ac0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7880
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x7abe
movq $0x0, -0x8(%rbp)
jmp 0x7ac8
jmp 0x7ac0
movq -0x10(%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/my_magic_quote.c
// Function: detect_magic_quote
int		detect_magic_quote(char *str)
{
  int		i;

  i = 0;
  while (str[i] != '\0')
    i += 1;
  if ((str[0] == '`') && (str[i - 1] == '`'))
    return (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 0x7b0b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7aef
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x60, %eax
jne 0x7b36
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x60, %eax
jne 0x7b36
movl $0x1, -0x4(%rbp)
jmp 0x7b3d
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/src/my_magic_quote.c
// Function: special_strdup
char		*special_strdup(char *str)
{
  int		i;
  int		j;
  char		*new_str;

  if ((new_str = malloc(sizeof(char)
			* (my_strlen(str) - 2) + 1)) == NULL)
    return (NULL);
  i = 1;
  j = 0;
  while (str[i + 1] != '\0')
    {
      new_str[j] = str[i];
      i += 1;
      j += 1;
    }
  new_str[j] = '\0';
  return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5820
subl $0x2, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7b8c
movq $0x0, -0x8(%rbp)
jmp 0x7bee
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7bda
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7b9a
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%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/my_magic_quote.c
// Function: check_magic_quote
int		check_magic_quote(t_info_shell *shell, char *str)
{
  char		**tab;
  char		**save;

  if ((tab = malloc(sizeof(char *) * 2)) == NULL)
    return (84);
  if ((tab[0] = special_strdup(str)) == NULL)
    return (84);
  tab[1] = NULL;
  save = shell->tab;
  shell->tab = tab;
  if (is_valid_command(shell) == NULL)
    my_printf("%s: %s", tab[0], COMMAND_ERROR);
  shell->tab = save;
  free_all(NULL, tab);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7c30
movl $0x54, -0x4(%rbp)
jmp 0x7cbe
movq -0x18(%rbp), %rdi
callq 0x7b50
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x7c4f
movl $0x54, -0x4(%rbp)
jmp 0x7cbe
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x36d0
cmpq $0x0, %rax
jne 0x7c9e
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0x1554(%rip), %rdi      # 0x91e4
leaq 0x1554(%rip), %rdx      # 0x91eb
movb $0x0, %al
callq 0x7ed1
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x5850
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/src/my_magic_quote.c
// Function: my_magic_quote
int		my_magic_quote(t_info_shell *shell)
{
  int		i;

  i = 0;
  while (shell->tab[i] != NULL)
    {
      if ((detect_magic_quote(shell->tab[i])) == 1)
	if ((check_magic_quote(shell, shell->tab[i])) == 84)
	  return (84);
      i += 1;
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7d44
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7ae0
cmpl $0x1, %eax
jne 0x7d39
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7c00
cmpl $0x54, %eax
jne 0x7d37
movl $0x54, -0x4(%rbp)
jmp 0x7d4b
jmp 0x7d39
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7ce3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/errmod.c
// Function: errmod_init
errmod_t *errmod_init(double depcorr)
{
    errmod_t *em;
    em = (errmod_t*)calloc(1, sizeof(errmod_t));
    if (!em) return NULL;
    em->depcorr = depcorr;
    cal_coef(em, depcorr, 0.03);
    return em;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x16060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x26311
movq $0x0, -0x8(%rbp)
jmp 0x2633c
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd 0x10ae01(%rip), %xmm1   # 0x131130
callq 0x26350
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/errmod.c
// Function: logbinomial_table
static double* logbinomial_table( const int n_size )
{
    /* prob distribution for binom var is p(k) = {n! \over k! (n-k)! } p^k (1-p)^{n-k} */
    /* this calcs p(k) = {log(n!) - log(k!) - log((n-k)!) */
    int k, n;
    double *logbinom = (double*)calloc(n_size * n_size, sizeof(double));
    if (!logbinom) return NULL;
    for (n = 1; n < n_size; ++n) {
        double lfn = lfact(n);
        for (k = 1; k <= n; ++k)
            logbinom[n<<8|k] = lfn - lfact(k) - lfact(n-k);
    }
    return logbinom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x16060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x271e7
movq $0x0, -0x8(%rbp)
jmp 0x2729d
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27295
movl -0x14(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x150b0
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x27285
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x150b0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x150b0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x27215
jmp 0x27287
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x271ee
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcfutils.c
// Function: bcf_remove_alleles
int bcf_remove_alleles(const bcf_hdr_t *header, bcf1_t *line, int rm_mask)
{
    int i;
    kbitset_t *rm_set = kbs_init(line->n_allele);
    for (i=1; i<line->n_allele; i++)
        if ( rm_mask & 1<<i ) kbs_insert(rm_set, i);

    bcf_remove_allele_set(header, line, rm_set);
    kbs_destroy(rm_set);

    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %eax
movl %eax, %edi
callq 0x98e20
movq %rax, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
jge 0x9be32
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x9be25
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x98e40
jmp 0x9be27
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9bde9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16270
movq -0x20(%rbp), %rdi
callq 0x9bd90
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kbitset.h
// Function: kbs_init2
static inline kbitset_t *kbs_init2(size_t ni, int fill)
{
	size_t n = (ni + KBS_ELTBITS-1) / KBS_ELTBITS;
	kbitset_t *bs =
		(kbitset_t *) malloc(sizeof(kbitset_t) + n * sizeof(unsigned long));
	if (bs == NULL) return NULL;
	bs->n = bs->n_max = n;
	memset(bs->b, fill? ~0 : 0, n * sizeof (unsigned long));
	// b[n] is always non-zero (a fact used by kbs_next()).
	bs->b[n] = kbs_last_mask(ni);
	if (fill) bs->b[n-1] &= bs->b[n];
	return bs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
subq $0x1, %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
addq $0x18, %rdi
callq 0x148d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9c1ac
movq $0x0, -0x8(%rbp)
jmp 0x9c231
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movq -0x20(%rbp), %rdx
shlq $0x3, %rdx
movzbl %al, %esi
callq 0x142a0
movq -0x10(%rbp), %rdi
callq 0x9c240
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
cmpl $0x0, -0x14(%rbp)
je 0x9c229
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
andq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
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/samtools[P]htslib/cram/cram_external.c
// Function: cram_container_get_coords
void cram_container_get_coords(cram_container *c,
                               int *refid, hts_pos_t *start, hts_pos_t *span) {
    if (refid)
        *refid = c->ref_seq_id;
    if (start)
        *start = c->ref_seq_start;
    if (span)
        *span  = c->ref_seq_span;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc2f68
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xc2f7e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0xc2f94
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_block_compression_hdr_set_DS
static int cram_block_compression_hdr_set_DS(cram_block_compression_hdr *ch,
                                             int ds, int new_rg) {
    if (!ch || !ch->codecs[ds])
        return -1;

    switch (ch->codecs[ds]->codec) {
    case E_HUFFMAN:
        if (ch->codecs[ds]->u.huffman.ncodes != 1)
            return -1;
        ch->codecs[ds]->u.huffman.codes[0].symbol = new_rg;
        return 0;

    case E_BETA:
        if (ch->codecs[ds]->u.beta.nbits != 0)
            return -1;
        ch->codecs[ds]->u.beta.offset = -new_rg;
        return 0;

    default:
        break;
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc2ff8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x280(%rax,%rcx,8)
jne 0xc3004
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc30b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0xc302d
jmp 0xc3020
movl -0x1c(%rbp), %eax
subl $0x6, %eax
je 0xc3070
jmp 0xc30b0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rax
cmpl $0x1, 0x60(%rax)
je 0xc304c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc30b9
movslq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq 0x280(%rax,%rdx,8), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc30b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rax
cmpl $0x0, 0x64(%rax)
je 0xc308f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc30b9
xorl %ecx, %ecx
subl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq 0x280(%rax,%rdx,8), %rax
movl %ecx, 0x60(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc30b9
jmp 0xc30b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_block_compression_hdr_decoder2encoder
int cram_block_compression_hdr_decoder2encoder(cram_fd *fd,
                                               cram_block_compression_hdr *ch) {
    int i;

    if (!ch)
        return -1;

    for (i = 0; i < DS_END; i++) {
        cram_codec *co = ch->codecs[i];
        if (!co)
            continue;

        if (-1 == cram_codec_decoder2encoder(fd, co))
            return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc30e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc313f
movl $0x0, -0x1c(%rbp)
cmpl $0x2f, -0x1c(%rbp)
jge 0xc3138
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc310a
jmp 0xc312d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x153e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0xc312b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc313f
jmp 0xc312d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc30e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_cid2ds_free
void cram_cid2ds_free(cram_cid2ds_t *cid2ds) {
    if (cid2ds) {
        if (cid2ds->hash)
            kh_destroy(cid, cid2ds->hash);
        free(cid2ds->ds);
        free(cid2ds->ds_a);
        free(cid2ds);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc319d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc317b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc31b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x14ef0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x14ef0
movq -0x8(%rbp), %rdi
callq 0x14ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_codec_iter_init
static void cram_codec_iter_init(cram_block_compression_hdr *hdr,
                                 cram_codec_iter *iter) {
    iter->hdr = hdr;
    iter->curr_map = NULL;
    iter->idx = 0;
    iter->is_tag = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_codec_iter_next
static cram_codec *cram_codec_iter_next(cram_codec_iter *iter,
                                        int *key) {
    cram_codec *cc = NULL;
    cram_block_compression_hdr *hdr = iter->hdr;

    if (!iter->is_tag) {
        // 1: Iterating through main data-series
        do {
            cc = hdr->codecs[iter->idx++];
        } while(!cc && iter->idx < DS_END);
        if (cc) {
            *key = cram_ds_to_key(iter->idx-1);
            return cc;
        }

        // Reset index for phase 2
        iter->idx = 0;
        iter->is_tag = 1;
    }

    do {
        if (!iter->curr_map)
            iter->curr_map = hdr->tag_encoding_map[iter->idx++];

        cc = iter->curr_map ? iter->curr_map->codec : NULL;
        if (cc) {
            *key = iter->curr_map->key;
            iter->curr_map = iter->curr_map->next;
            return cc;
        }
    } while (iter->idx < CRAM_MAP_HASH);

    // End of codecs
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xc35b7
jmp 0xc3533
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
movq 0x280(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jne 0xc356f
movq -0x10(%rbp), %rax
cmpl $0x2f, 0x10(%rax)
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xc3533
cmpq $0x0, -0x20(%rbp)
je 0xc35a1
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
subl $0x1, %edi
callq 0xc5060
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc3664
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0xc35b9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc35ea
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
movq 0x180(%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc3607
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xc360f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xc360f
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc364c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc3664
jmp 0xc364e
movq -0x10(%rbp), %rax
cmpl $0x20, 0x10(%rax)
jl 0xc35b9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_cid2ds_query
int *cram_cid2ds_query(cram_cid2ds_t *c2d, int content_id, int *n) {
    *n = 0;
    if (!c2d || !c2d->hash)
        return NULL;

    khiter_t k = kh_get(cid, c2d->hash, content_id);
    if (k == kh_end(c2d->hash))
        return NULL;

    if (!c2d->ds_a) {
        c2d->ds_a = malloc(c2d->ds_idx * sizeof(int));
        if (!c2d->ds_a)
            return NULL;
    }

    int dsi = kh_value(c2d->hash, k); // initial ds array index from hash
    int idx = 0;
    while (dsi >= 0) {
        c2d->ds_a[idx++] = c2d->ds[dsi].data_series;
        dsi = c2d->ds[dsi].next;      // iterate over list within ds array
    }

    *n = idx;
    return c2d->ds_a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0xc3a1f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc3a2c
movq $0x0, -0x8(%rbp)
jmp 0xc3b0c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xc3b20
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jne 0xc3a5b
movq $0x0, -0x8(%rbp)
jmp 0xc3b0c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xc3a99
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x148d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xc3a97
movq $0x0, -0x8(%rbp)
jmp 0xc3b0c
jmp 0xc3a99
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xc3af7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x28(%rbp)
jmp 0xc3ab6
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %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/samtools[P]htslib/cram/cram_external.c
// Function: cram_describe_encodings
int cram_describe_encodings(cram_block_compression_hdr *hdr, kstring_t *ks) {
    cram_codec_iter citer;
    cram_codec_iter_init(hdr, &citer);
    cram_codec *codec;
    int key, r = 0;

    while ((codec = cram_codec_iter_next(&citer, &key))) {
        char key_s[4] = {0};
        int key_i = 0;
        if (key>>16) key_s[key_i++] = key>>16;
        key_s[key_i++] = (key>>8)&0xff;
        key_s[key_i++] = key&0xff;
        r |= ksprintf(ks, "\t%s\t", key_s) < 0;
        r |= cram_codec_describe(codec, ks) < 0;
        r |= kputc('\n', ks) < 0;
    }

    return r ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc34c0
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xc3500
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xc3d7c
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x142a0
movl $0x0, -0x40(%rbp)
movl -0x34(%rbp), %eax
sarl $0x10, %eax
cmpl $0x0, %eax
je 0xc3cda
movl -0x34(%rbp), %eax
sarl $0x10, %eax
movb %al, %cl
movl -0x40(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x40(%rbp)
cltq
movb %cl, -0x3c(%rbp,%rax)
movl -0x34(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movl -0x40(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x40(%rbp)
cltq
movb %cl, -0x3c(%rbp,%rax)
movl -0x34(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movl -0x40(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x40(%rbp)
cltq
movb %cl, -0x3c(%rbp,%rax)
movq -0x10(%rbp), %rdi
leaq -0x3c(%rbp), %rdx
leaq 0x77856(%rip), %rsi     # 0x13b578
movb $0x0, %al
callq 0x14400
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x156c0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0xc3da0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xc3c84
movl -0x38(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_slice_hdr_get_coords
void cram_slice_hdr_get_coords(cram_block_slice_hdr *h,
                               int *refid, hts_pos_t *start, hts_pos_t *span) {
    if (refid)
        *refid = h->ref_seq_id;
    if (start)
        *start = h->ref_seq_start;
    if (span)
        *span  = h->ref_seq_span;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc3e88
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xc3e9e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0xc3eb4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_block_append
int cram_block_append(cram_block *b, const void *data, int size) {
    BLOCK_APPEND(b, data, size);
    return 0;

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0xc40e0
cmpl $0x0, %eax
jge 0xc40bb
jmp 0xc40c4
movl $0x0, -0x4(%rbp)
jmp 0xc40cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_copy_slice
int cram_copy_slice(cram_fd *in, cram_fd *out, int32_t num_slice) {
    int32_t i, j;

    for (i = 0; i < num_slice; i++) {
        cram_block *blk;
        cram_block_slice_hdr *hdr;

        if (!(blk = cram_read_block(in)))
            return -1;
        if (!(hdr = cram_decode_slice_header(in, blk))) {
            cram_free_block(blk);
            return -1;
        }

        if (cram_write_block(out, blk) != 0) {
            cram_free_block(blk);
            return -1;
        }
        cram_free_block(blk);

        int num_blocks = cram_slice_hdr_get_num_blocks(hdr);
        for (j = 0; j < num_blocks; j++) {
            blk = cram_read_block(in);
            if (!blk || cram_write_block(out, blk) != 0) {
                if (blk) cram_free_block(blk);
                return -1;
            }
            cram_free_block(blk);
        }
        cram_free_slice_header(hdr);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xc46d6
movq -0x10(%rbp), %rdi
callq 0x149c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc45f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc46dd
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x16450
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xc4621
movq -0x30(%rbp), %rdi
callq 0x151e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc46dd
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15900
cmpl $0x0, %eax
je 0xc4648
movq -0x30(%rbp), %rdi
callq 0x151e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc46dd
movq -0x30(%rbp), %rdi
callq 0x151e0
movq -0x38(%rbp), %rdi
callq 0x15e00
movl %eax, -0x3c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0xc46bf
movq -0x10(%rbp), %rdi
callq 0x149c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc4692
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15900
cmpl $0x0, %eax
je 0xc46ab
cmpq $0x0, -0x30(%rbp)
je 0xc46a2
movq -0x30(%rbp), %rdi
callq 0x151e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc46dd
movq -0x30(%rbp), %rdi
callq 0x151e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc4664
movq -0x38(%rbp), %rdi
callq 0x15a10
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc45ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_external.c
// Function: cram_skip_container
static int cram_skip_container(cram_fd *in, cram_container *c) {
    // Compression header
    cram_block *blk;
    if (!(blk = cram_read_block(in)))
        return -1;
    cram_free_block(blk);

    int i;
    for (i = 0; i < c->num_landmarks; i++) {
        cram_block_slice_hdr *hdr;

        if (!(blk = cram_read_block(in)))
            return -1;
        if (!(hdr = cram_decode_slice_header(in, blk))) {
            cram_free_block(blk);
            return -1;
        }
        cram_free_block(blk);

        int num_blocks = cram_slice_hdr_get_num_blocks(hdr), j;
        for (j = 0; j < num_blocks; j++) {
            blk = cram_read_block(in);
            if (!blk) {
                cram_free_slice_header(hdr);
                return -1;
            }
            cram_free_block(blk);
        }
        cram_free_slice_header(hdr);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x149c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc4c1f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4d03
movq -0x20(%rbp), %rdi
callq 0x151e0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xc4cfc
movq -0x10(%rbp), %rdi
callq 0x149c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc4c5e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4d03
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16450
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc4c87
movq -0x20(%rbp), %rdi
callq 0x151e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4d03
movq -0x20(%rbp), %rdi
callq 0x151e0
movq -0x30(%rbp), %rdi
callq 0x15e00
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc4ce5
movq -0x10(%rbp), %rdi
callq 0x149c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc4cd1
movq -0x30(%rbp), %rdi
callq 0x15a10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4d03
movq -0x20(%rbp), %rdi
callq 0x151e0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xc4ca3
movq -0x30(%rbp), %rdi
callq 0x15a10
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc4c2f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-extend.c
// Function: dump_stack
void dump_stack() {
  CELL i;
  if (sp == 0)
    return;
  printf("\nStack: ");
  for (i = 1; i <= sp; i++) {
    if (i == sp)
      printf("[ TOS: %lld ]", (long long)data[i]);
    else
      printf("%lld ", (long long)data[i]);
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x3f71(%rip)      # 0x51b0
jne 0x1246
jmp 0x12c8
leaq 0x1dcb(%rip), %rdi      # 0x3018
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x3f4c(%rip), %eax      # 0x51b0
jg 0x12ba
movl -0x4(%rbp), %eax
cmpl 0x3f41(%rip), %eax      # 0x51b0
jne 0x1290
movslq -0x4(%rbp), %rcx
leaq 0x3f44(%rip), %rax      # 0x51c0
movslq (%rax,%rcx,4), %rsi
leaq 0x1d9a(%rip), %rdi      # 0x3021
movb $0x0, %al
callq 0x1070
jmp 0x12ad
movslq -0x4(%rbp), %rcx
leaq 0x3f25(%rip), %rax      # 0x51c0
movslq (%rax,%rcx,4), %rsi
leaq 0x1d89(%rip), %rdi      # 0x302f
movb $0x0, %al
callq 0x1070
jmp 0x12af
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x125b
leaq 0x1e9c(%rip), %rdi      # 0x315d
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-extend.c
// Function: include_file
int include_file(char *fname) {
  FILE *fp;
  char source[2049];
  int inBlock = 0;
  int tokens = 0;
  fp = fopen(fname, "r");
  if (fp == NULL)
    return 0;
  while (!feof(fp))
  {
    read_token(fp, source, 0, 2048);
    if (strcmp(source, "~~~") == 0) {
      if (inBlock == 0)
        inBlock = 1;
      else
        inBlock = 0;
    } else {
      if (inBlock == 1) {
        evaluate(source);
        tokens++;
      }
    }
  }
  fclose(fp);
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movq %rdi, -0x10(%rbp)
movl $0x0, -0x824(%rbp)
movl $0x0, -0x828(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1dd7(%rip), %rsi      # 0x30d5
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131a
movl $0x0, -0x4(%rbp)
jmp 0x13c0
jmp 0x131c
movq -0x18(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1333
jmp 0x13ae
movq -0x18(%rbp), %rdi
leaq -0x820(%rbp), %rsi
xorl %edx, %edx
movl $0x800, %ecx            # imm = 0x800
callq 0x13d0
leaq -0x820(%rbp), %rdi
leaq 0x1cdd(%rip), %rsi      # 0x3035
callq 0x1090
cmpl $0x0, %eax
jne 0x1383
cmpl $0x0, -0x824(%rbp)
jne 0x1377
movl $0x1, -0x824(%rbp)
jmp 0x1381
movl $0x0, -0x824(%rbp)
jmp 0x13a9
cmpl $0x1, -0x824(%rbp)
jne 0x13a7
leaq -0x820(%rbp), %rdi
callq 0x14b0
movl -0x828(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x828(%rbp)
jmp 0x13a9
jmp 0x131c
movq -0x18(%rbp), %rdi
callq 0x1050
movl -0x828(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopl (%rax)