LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: AssessPerc
int AssessPerc(QUALITY *Qual)
{

  float TP, TN, FP, FN;

  TP = (float)Qual->TP; 
  TN = (float)Qual->TN; 
  FP = (float)Qual->FP; 
  FN =(float)Qual->FN;

  Qual->Perc = (TP+TN)/(TP+TN+FP+FN);

  return(SUCCESS);
}

// Assembly:
movsd (%rdi), %xmm0
cvtdq2ps %xmm0, %xmm0
cvtsi2ssl 0x8(%rdi), %xmm1
cvtsi2ssl 0xc(%rdi), %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
addss %xmm0, %xmm3
addss %xmm3, %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm3
movss %xmm3, 0x14(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: ExcludeObvious
void ExcludeObvious(char *Asn1, char *Asn2, char *KnownAsn, int Length)
{
  register int i;

  for( i=0; i<Length; i++ )
    if( Asn1[i] == Asn2[i] ) {
      KnownAsn[i] = 'X';
      Asn1[i] = 'X';
      Asn2[i] = 'X';
    }
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movb $0x58, %r8b
cmpq %rax, %rcx
je 0x17722
movb (%rdi,%rax), %r9b
cmpb (%rsi,%rax), %r9b
jne 0x1771d
movb %r8b, (%rdx,%rax)
movb %r8b, (%rdi,%rax)
movb %r8b, (%rsi,%rax)
incq %rax
jmp 0x17702
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/p_endmdl.c
// Function: Process_ENDMDL
int Process_ENDMDL(BUFFER Buffer, CHAIN **Chain, int *ChainNumber)
{

  int CC;

  for( CC=0; CC < *ChainNumber; CC++ )
    Chain[CC]->Ter = 1;
  
  return(SUCCESS);
}

// Assembly:
xorl %eax, %eax
movslq (%rdx), %rcx
cmpq %rcx, %rax
jge 0x1773e
movq (%rsi,%rax,8), %rcx
movl $0x1, 0xc(%rcx)
incq %rax
jmp 0x17726
pushq $0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/contact_map.c
// Function: ContactMap
void ContactMap(CHAIN **Chain, int NChain, COMMAND *Cmd )
{

  register int Res1, Res2;
  int Cn1, Cn2, CA1, CA2;
  float D;
  
  for( Cn1=0; Cn1<NChain; Cn1++ ) {
    
    if( !Chain[Cn1]->Valid )
      continue;


    for( Cn2=0; Cn2<NChain; Cn2++ ) {

      if( !Chain[Cn2]->Valid )
	continue;

      for( Res1=0; Res1<Chain[Cn1]->NRes; Res1++ ) {

	if( !FindAtom(Chain[Cn1],Res1,"CA",&CA1) )
	  continue;

	for( Res2=0; Res2<Chain[Cn2]->NRes; Res2++ ) {
	  
	  if( !FindAtom(Chain[Cn2],Res2,"CA",&CA2) )
	    continue;

	  D = Dist(Chain[Cn1]->Rsd[Res1]->Coord[CA1],
		   Chain[Cn2]->Rsd[Res2]->Coord[CA2]);
	  printf("%c %d <-> %c %d : %7.3f\n",
		 SpaceToDash(Chain[Cn1]->Id),Res1,
		 SpaceToDash(Chain[Cn2]->Id),Res2,D);
	}
      }
    }
  }
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %rax, 0x18(%rsp)
movl %esi, %eax
movq %rax, 0x20(%rsp)
cmpq 0x18(%rsp), %r12
je 0x17c34
movq (%rbx,%r12,8), %rdi
cmpl $0x0, 0x58(%rdi)
je 0x17c2c
xorl %r14d, %r14d
cmpq 0x20(%rsp), %r14
je 0x17c2c
movq (%rbx,%r14,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x17c24
xorl %ebp, %ebp
movslq (%rdi), %rax
cmpq %rax, %rbp
jge 0x17c24
movl %ebp, %esi
leaq 0x2292(%rip), %rdx      # 0x19de8
leaq 0x14(%rsp), %rcx
callq 0x4777
testl %eax, %eax
je 0x17c18
xorl %r15d, %r15d
movq (%rbx,%r14,8), %rdi
movslq (%rdi), %rax
cmpq %rax, %r15
jge 0x17c18
movl %r15d, %esi
leaq 0x2263(%rip), %rdx      # 0x19de8
leaq 0x10(%rsp), %rcx
callq 0x4777
testl %eax, %eax
je 0x17c10
movq (%rbx,%r12,8), %rax
movq 0x68(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0xc, %rcx, %rdi
addq (%rax,%rbp,8), %rdi
movl $0x188, %edx            # imm = 0x188
addq %rdx, %rdi
movq (%rbx,%r14,8), %rax
movq 0x68(%rax), %rax
movslq 0x10(%rsp), %rcx
imulq $0xc, %rcx, %rsi
addq (%rax,%r15,8), %rsi
addq %rdx, %rsi
callq 0x3abc
movss %xmm0, 0xc(%rsp)
movq (%rbx,%r12,8), %rax
movsbl 0x40(%rax), %edi
callq 0x4969
movsbl %al, %r13d
movq (%rbx,%r14,8), %rax
movsbl 0x40(%rax), %edi
callq 0x4969
movsbl %al, %ecx
cvtss2sd 0xc(%rsp), %xmm0
leaq 0x2506(%rip), %rdi      # 0x1a107
movl %r13d, %esi
movl %ebp, %edx
movl %r15d, %r8d
movb $0x1, %al
callq 0x20d0
incq %r15
jmp 0x17b6b
incq %rbp
movq (%rbx,%r12,8), %rdi
jmp 0x17b41
incq %r14
jmp 0x17b26
incq %r12
jmp 0x17b0a
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_03/syscalls.c
// Function: main
int main(void)
{
  FILE *file_in_p;
  FILE *file_out_p;

  if ((file_in_p = file_open("syscalls.c", "r")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  if ((file_out_p = file_open("out.txt", "w")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  char c;
  while ((c = getc(file_in_p)) != EOF)
  {
    putc(c, file_out_p);
  }
  file_close(file_in_p);
  file_close(file_out_p);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xc09(%rip), %rdi       # 0x2004
leaq 0xc0d(%rip), %rsi       # 0x200f
callq 0x12d2
testq %rax, %rax
je 0x147b
movq %rax, %rbx
leaq 0xc1c(%rip), %rdi       # 0x2032
leaq 0xc1d(%rip), %rsi       # 0x203a
callq 0x12d2
testq %rax, %rax
je 0x147b
movq %rax, %r14
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x1445
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
jmp 0x144d
movq %rbx, %rdi
callq 0x11ac
cmpb $-0x1, %al
je 0x1491
movl (%r14), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%r14)
testl %ecx, %ecx
jle 0x146e
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %al, (%rcx)
jmp 0x142a
movsbl %al, %edi
movq %r14, %rsi
callq 0x1222
jmp 0x142a
leaq 0xb8f(%rip), %rsi       # 0x2011
pushq $0x1
popq %rbx
pushq $0x21
popq %rdx
movl %ebx, %edi
callq 0x1040
jmp 0x14a3
movq %rbx, %rdi
callq 0x13cd
movq %r14, %rdi
callq 0x13cd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/main.c
// Function: master_loop
int		master_loop(t_control *control)
{
	t_list	*tokens_list;
	t_btree	*ast;

	while (!control->quit)
	{
		if (!termios_enable_raw_mode(control, &control->termios_default))
			break ;
		tokens_list = input_root(control);
		if (!termios_reset_cooked_mode(control, &control->termios_default))
			break ;
		if (control->quit || control->ctrl_c || control->lexer_end.unexpected)
			continue;
		ast = parser_root(tokens_list, control);
		if (control->quit)
			break ;
		exe_root(ast, control);
		btree_clear(&ast, del_token);
	}
	return (control->exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3c(%rdi), %r14
leaq 0x400(%rip), %r15       # 0x2747
leaq 0x8(%rsp), %r12
testb $0x1, (%rbx)
jne 0x23b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3eb8
testl %eax, %eax
je 0x23b2
movq %rbx, %rdi
callq 0x3bd4
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f79
testl %eax, %eax
je 0x23b2
testb $0x3, (%rbx)
jne 0x234c
cmpl $0x0, 0x2c(%rbx)
jne 0x234c
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5db6
movq %rax, 0x8(%rsp)
testb $0x1, (%rbx)
jne 0x23b2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x60c8
movq %r12, %rdi
movq %r15, %rsi
callq 0xa418
jmp 0x234c
movl 0x4(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/main.c
// Function: main
int		main(void)
{
	int				exit_status;
	t_control		control;

	ft_signalhandler_enable();
	if (!control_init_struct(&control) ||
		!(termios_enable_raw_mode(&control, &control.termios_default)))
	{
		ft_perror(NULL, NULL, errno ? strerror(errno) : "Couldn't initialize");
		control_free_struct(&control);
		return (1);
	}
	exit_status = master_loop(&control);
	control_free_struct(&control);
	terminfo_reset_terminal();
	termios_reset_cooked_mode(&control, &control.termios_default);
	return (exit_status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
callq 0x87d8
movq %rsp, %rdi
callq 0x58a8
testl %eax, %eax
je 0x241a
leaq 0x3c(%rsp), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3eb8
testl %eax, %eax
je 0x241a
movq %rsp, %r14
movq %r14, %rdi
callq 0x232c
movl %eax, %ebp
movq %r14, %rdi
callq 0x5a06
callq 0x4105
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f79
jmp 0x244a
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
je 0x242f
callq 0x2210
movq %rax, %rdx
jmp 0x2436
leaq 0x8bce(%rip), %rdx      # 0xb004
xorl %edi, %edi
xorl %esi, %esi
callq 0x24e8
movq %rsp, %rdi
callq 0x5a06
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_fork
void	ft_fork(pid_t *pid)
{
	*pid = fork();
	if (*pid == -1)
		ft_exit("fork", NULL, strerror(errno), EXIT_FAILURE);
	errno = 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2220
movl %eax, %ebp
movl %eax, (%rbx)
callq 0x2040
cmpl $-0x1, %ebp
je 0x24b7
andl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl (%rax), %edi
callq 0x2210
leaq 0x8b58(%rip), %rdi      # 0xb01d
pushq $0x1
popq %rcx
xorl %esi, %esi
movq %rax, %rdx
callq 0x2485
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_perror
int		ft_perror(char *cmd, char *param, char *str)
{
	const int fd = STDERR_FILENO;

	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	if (cmd)
	{
		ft_putstr_fd(cmd, fd);
		ft_putstr_fd(": ", fd);
	}
	if (param)
	{
		ft_putstr_fd("`", fd);
		ft_putstr_fd(param, fd);
		ft_putstr_fd("': ", fd);
	}
	if (errno && !str)
		str = strerror(errno);
	if (str)
	{
		ft_putstr_fd("Error: ", fd);
		ft_putendl_fd(str, fd);
	}
	ft_putstr_fd("\033[0m", fd);
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8b23(%rip), %rdi      # 0xb022
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x9668
leaq 0x8b1a(%rip), %rdi      # 0xb02a
movl %ebp, %esi
callq 0x9668
testq %r15, %r15
je 0x2537
pushq $0x2
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x9668
leaq 0x8f3e(%rip), %rdi      # 0xb46e
movl %ebp, %esi
callq 0x9668
testq %r14, %r14
je 0x2565
leaq 0x8d30(%rip), %rdi      # 0xb273
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x9668
movq %r14, %rdi
movl %ebp, %esi
callq 0x9668
leaq 0x8ad8(%rip), %rdi      # 0xb036
movl %ebp, %esi
callq 0x9668
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
sete %al
testq %rbx, %rbx
setne %cl
orb %al, %cl
jne 0x2583
callq 0x2210
movq %rax, %rbx
testq %rbx, %rbx
je 0x25a3
leaq 0x8aab(%rip), %rdi      # 0xb03a
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x9668
movq %rbx, %rdi
movl %ebp, %esi
callq 0x95cc
leaq 0x96a0(%rip), %rdi      # 0xbc4a
pushq $0x2
popq %rsi
callq 0x9668
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_ambiguous_redirect
void	ft_ambiguous_redirect(char *str, int fd)
{
	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	ft_putstr_fd(str, fd);
	ft_putstr_fd(": ambiguous redirect\n", fd);
	ft_putstr_fd("\033[0m", fd);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8a52(%rip), %rdi      # 0xb022
callq 0x9668
leaq 0x8a4e(%rip), %rdi      # 0xb02a
movl %ebx, %esi
callq 0x9668
movq %r14, %rdi
movl %ebx, %esi
callq 0x9668
leaq 0x8a4e(%rip), %rdi      # 0xb042
movl %ebx, %esi
callq 0x9668
leaq 0x9648(%rip), %rdi      # 0xbc4a
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9668
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_root
t_list	*lexer_root(char *input, t_control *control)
{
	t_list	*tokens_head;
	t_list	*tokens_elem;
	t_token	*new_token;
	int		i;

	i = 0;
	tokens_head = NULL;
	while (input[i])
	{
		tokens_elem = NULL;
		if ((!(new_token = lexer_build_next_token(input, &i, control)) &&
		control->quit) || (new_token && !(tokens_elem = ft_lstnew(new_token))))
		{
			control->quit = 1;
			del_token(new_token);
			ft_lstclear(&tokens_head, del_token);
			return (NULL);
		}
		ft_lstadd_back(&tokens_head, tokens_elem);
		//debug_token_struct(new_token);
	}
	ft_bzero(&control->lexer_end, sizeof(lexer_end));
	if (!lexer_end(tokens_head, control))
		ft_lstclear(&tokens_head, del_token);
	//debug_lexer_flags(control);
	//debug_tokens_list(tokens_head);
	return (tokens_head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
movq %rsp, %r12
andq $0x0, (%r12)
xorl %eax, %eax
cltq
cmpb $0x0, (%r14,%rax)
je 0x267d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26db
movq %rax, %r13
testq %rax, %rax
je 0x2664
movq %r13, %rdi
callq 0x9e58
testq %rax, %rax
jne 0x266c
jmp 0x26ae
movb (%rbx), %al
testb $0x1, %al
jne 0x26b0
xorl %eax, %eax
movq %r12, %rdi
movq %rax, %rsi
callq 0x9dac
movl 0xc(%rsp), %eax
jmp 0x2636
leaq 0x28(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x93c8
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x2e80
testl %eax, %eax
jne 0x26a8
leaq 0xa7(%rip), %rsi        # 0x2747
movq %rsp, %rdi
callq 0x9de8
movq (%rsp), %rax
jmp 0x26cd
movb (%rbx), %al
orb $0x1, %al
movb %al, (%rbx)
movq %r13, %rdi
callq 0x2747
leaq 0x84(%rip), %rsi        # 0x2747
movq %rsp, %rdi
callq 0x9de8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_build_next_token
t_token	*lexer_build_next_token(const char *input, int *j, t_control *control)
{
	t_token		*token;

	token = NULL;
	while (input[*j] == ' ')
		(*j)++;
	if (!input[*j])
		return (token);
	if (!(token = lexer_init_token()) ||
		!lexer_find_token(input, j, token))
	{
		control->quit = 1;
		del_token(token);
		return (NULL);
	}
	return (token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rcx
leal 0x1(%rcx), %eax
addq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x20, %edx
jne 0x2707
movl %eax, (%r14)
incq %rcx
incl %eax
jmp 0x26f5
testl %edx, %edx
je 0x2735
callq 0x27a3
movq %rax, %r12
testq %rax, %rax
je 0x272a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x27ac
testl %eax, %eax
jne 0x2738
orb $0x1, (%rbx)
movq %r12, %rdi
callq 0x2747
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_root.c
// Function: del_token
void	del_token(void *token)
{
	if (!token)
		return ;
	if (token_id(token) == CMD)
		free_t_simple_cmd((t_simple_cmd**)(((t_token *)token)->str));
	else if (token_id(token) == LIST)
		ft_lstclear((t_list **)&(((t_token *)token)->str), del_token);
	else
		ft_free((void **)&(((t_token *)token)->str));
	ft_free(&token);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x279d
movq %rdi, %rbx
callq 0x5fc8
cmpl $0x10, %eax
jne 0x276d
movq (%rbx), %rdi
callq 0x8634
jmp 0x2793
movq %rbx, %rdi
callq 0x5fc8
cmpl $0xf, %eax
jne 0x278b
leaq -0x3a(%rip), %rsi       # 0x2747
movq %rbx, %rdi
callq 0x9de8
jmp 0x2793
movq %rbx, %rdi
callq 0xa018
leaq 0x8(%rsp), %rdi
callq 0xa018
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_find_token.c
// Function: lexer_find_token
int	lexer_find_token(const char *input, int *j, t_token *token)
{
	if (!input[*j])
		return (1);
	if (input[*j] == '\\')
		return (lexer_just_token(input, j, token));
	else if (ft_strchr("\"\'", input[*j]))
		return (lexer_quoted(input, j, token));
	else if (ft_strchr("&<>()|;", input[*j]))
		return (lexer_operator(input, j, token));
	else if (ft_isdigit(input[*j]))
		return (lexer_token_or_indirection(input, j, token));
	return (lexer_just_token(input, j, token));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq (%rsi), %rax
movzbl (%rdi,%rax), %eax
testl %eax, %eax
je 0x27dd
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x5c, %eax
jne 0x27e6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2b28
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movsbl %al, %esi
leaq 0x8868(%rip), %rdi      # 0xb058
callq 0x9ab4
testq %rax, %rax
je 0x280d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2868
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x883f(%rip), %rdi      # 0xb05b
callq 0x9ab4
testq %rax, %rax
je 0x2839
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x29e8
movslq (%r14), %rax
movsbl (%r15,%rax), %edi
callq 0x940c
testl %eax, %eax
je 0x27ca
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c30
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted
int	lexer_quoted(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	token->open_quote = 1;
	if (c == '\'')
	{
		token->id = S_QUOTE;
		return (lexer_quoted_single(input, c, j, token));
	}
	else
	{
		token->id = D_QUOTE;
		return (lexer_quoted_double(input, c, j, token));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movb (%rdi,%rax), %r12b
movsbl %r12b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0x9f68
testl %eax, %eax
je 0x28bf
incl (%r14)
orb $0x1, 0x10(%rbx)
cmpb $0x27, %r12b
jne 0x28ca
movl $0x8, 0x8(%rbx)
pushq $0x27
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28e9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x9, 0x8(%rbx)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2951
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_single
int	lexer_quoted_single(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movl (%rdx), %eax
pushq $0x1
popq %rbp
cltq
movb (%r15,%rax), %al
testb %al, %al
je 0x2946
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9f68
testl %eax, %eax
je 0x2944
movslq (%r14), %rcx
leal 0x1(%rcx), %eax
cmpb %r12b, (%r15,%rcx)
movl %eax, (%r14)
jne 0x2902
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27ac
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_double
int	lexer_quoted_double(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (!token->esc_next && input[*j] == '\\' && lexer_jump_esc(j, token))
			continue;
		else if (!token->esc_next && input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
pushq $0x1
popq %rbp
movslq (%r14), %rax
movb (%r15,%rax), %al
testb %al, %al
je 0x29be
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9f68
testl %eax, %eax
je 0x29bc
movb 0x10(%rbx), %al
testb $0x2, %al
jne 0x29a5
movslq (%r14), %rcx
cmpb $0x5c, (%r15,%rcx)
jne 0x29a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x285d
testl %eax, %eax
jne 0x2968
movb 0x10(%rbx), %al
testb $0x2, %al
jne 0x29b2
movslq (%r14), %rcx
cmpb %r12b, (%r15,%rcx)
je 0x29c9
andb $-0x3, %al
movb %al, 0x10(%rbx)
incl (%r14)
jmp 0x2968
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incl %ecx
movl %ecx, (%r14)
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27ac
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator
int		lexer_operator(const char *input, int *j, t_token *token)
{
	if (token->str)
		return (1);
	lexer_set_operator_id(token, input[*j]);
	if (ft_strchr("();", input[*j]))
	{
		(*j)++;
		if (!(token->str = ft_strdup((char	[2]){input[*j - 1], '\0'})))
			return (0);
		return (1);
	}
	else if (ft_strchr("<>&|", input[*j]))
		return (lexer_operator2(input, j, token));
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdx)
je 0x29fc
pushq $0x1
popq %rax
jmp 0x2a58
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movsbl (%rdi,%rax), %esi
movq %rdx, %rdi
callq 0x2a93
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x865d(%rip), %rdi      # 0xb080
callq 0x9ab4
movslq (%r14), %rcx
testq %rax, %rax
je 0x2a62
leal 0x1(%rcx), %eax
movl %eax, (%r14)
movb (%r15,%rcx), %al
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
callq 0x9aec
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsbl (%r15,%rcx), %esi
leaq 0x8616(%rip), %rdi      # 0xb084
callq 0x9ab4
testq %rax, %rax
je 0x2a8f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2abc
xorl %eax, %eax
jmp 0x2a58
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_set_operator_id
void	lexer_set_operator_id(t_token *token, char c)
{
	int			i;
	char		(*op_ids)[2];

	op_ids = (char	[][2]){{'(', LBRACE}, {')', RBRACE},
	{'|', PIPE}, {'&', AND}, {';', SEMI}, {'<', LESS}, {'>', GREAT}, {0, 0}};
	i = -1;
	while (op_ids[++i][0])
		if (op_ids[i][0] == c)
			token->id = op_ids[i][1];
}

// Assembly:
movaps 0x85d6(%rip), %xmm0     # 0xb070
leaq -0x17(%rsp), %rax
movaps %xmm0, -0x1(%rax)
movb -0x1(%rax), %cl
testb %cl, %cl
je 0x2abb
cmpb %sil, %cl
jne 0x2ab5
movsbl (%rax), %ecx
movl %ecx, 0x8(%rdi)
addq $0x2, %rax
jmp 0x2aa3
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator2
int		lexer_operator2(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	if (input[*j] == c)
	{
		token->id++;
		(*j)++;
		if (!ft_strappend(&(token->str), c))
			return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq (%rsi), %rax
movb (%rdi,%rax), %r13b
movsbl %r13b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0x9f68
xorl %ebx, %ebx
testl %eax, %eax
je 0x2b14
movslq (%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
cmpb %r13b, 0x1(%r12,%rax)
jne 0x2b11
incl 0x8(%r14)
incl (%r15)
movq %r14, %rdi
movl %ebp, %esi
callq 0x9f68
testl %eax, %eax
je 0x2b14
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_just_token
int	lexer_just_token(const char *input, int *j, t_token *token)
{
	while (input[*j] && (token->esc_next || input[*j] != ' '))
	{
		if (!token->esc_next && ft_strchr("\"\'", input[*j]))
			return (lexer_quoted(input, j, token));
		else if (!token->esc_next && ft_strchr("&<>()|;", input[*j]))
			return (1);
		else if (!token->esc_next && input[*j] == '\\')
		{
			token->esc_next = 1;
			if (!ft_strappend(&(token->str), input[*j]))
				return (0);
			(*j)++;
			continue;
		}
		else if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rsi), %eax
pushq $0x1
popq %rbx
leaq 0x8510(%rip), %r13      # 0xb058
leaq 0x850c(%rip), %rbp      # 0xb05b
movslq %eax, %rcx
movsbl (%r12,%rcx), %esi
testl %esi, %esi
je 0x2c03
movb 0x10(%r14), %cl
movl %ecx, %edx
andb $0x2, %dl
movl %esi, %edi
xorb $0x20, %dil
orb %dl, %dil
je 0x2c03
testb $0x2, %cl
jne 0x2b94
movq %r13, %rdi
callq 0x9ab4
testq %rax, %rax
jne 0x2c14
movb 0x10(%r14), %cl
movl (%r15), %eax
testb $0x2, %cl
jne 0x2bb4
cltq
movsbl (%r12,%rax), %esi
movq %rbp, %rdi
callq 0x9ab4
testq %rax, %rax
jne 0x2c03
movb 0x10(%r14), %cl
movl (%r15), %eax
cltq
movb (%r12,%rax), %al
testb $0x2, %cl
jne 0x2be0
cmpb $0x5c, %al
jne 0x2be0
orb $0x2, %cl
movb %cl, 0x10(%r14)
movslq (%r15), %rax
movsbl (%r12,%rax), %esi
movq %r14, %rdi
callq 0x9f68
testl %eax, %eax
jne 0x2bf4
jmp 0x2c01
movsbl %al, %esi
movq %r14, %rdi
callq 0x9f68
testl %eax, %eax
je 0x2c01
andb $-0x3, 0x10(%r14)
movl (%r15), %eax
incl %eax
movl %eax, (%r15)
jmp 0x2b4f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2868
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_token_or_indirection
int	lexer_token_or_indirection(const char *input, int *j, t_token *token)
{
	while (ft_isdigit(input[*j]))
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		(*j)++;
	}
	if (input[*j] && input[*j] != ' ')
	{
		if (ft_strchr("&()|;", input[*j]))
			return (1);
		else if (ft_strchr("<>", input[*j]))
			return (lexer_indirection(input, j, token));
		else
			return (lexer_just_token(input, j, token));
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cltq
movsbl (%r15,%rax), %edi
callq 0x940c
movslq (%r14), %rcx
movsbl (%r15,%rcx), %esi
testl %eax, %eax
je 0x2c70
movq %rbx, %rdi
callq 0x9f68
testl %eax, %eax
je 0x2cbb
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
jmp 0x2c42
pushq $0x1
popq %rbp
testb $-0x21, %sil
je 0x2cbd
leaq 0x8409(%rip), %rdi      # 0xb089
callq 0x9ab4
testq %rax, %rax
jne 0x2cbd
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x83f6(%rip), %rdi      # 0xb08f
callq 0x9ab4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
testq %rax, %rax
je 0x2cca
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2cd5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b28
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_braces_equal
int		lexer_braces_equal(t_list *tk_head, t_control *control, t_token *last)
{
	int		brace[2];

	brace[0] = 0;
	brace[1] = 0;
	while (tk_head && !control->lexer_end.unexpected)
	{
		if (((t_token *)tk_head->content)->id == LBRACE)
			brace[0]++;
		else if (((t_token *)tk_head->content)->id == RBRACE)
			brace[1]++;
		if (brace[0] < brace[1])
			control->lexer_end.unexpected = RBRACE;
		tk_head = tk_head->next;
	}
	if (brace[0] > brace[1])
	{
		control->lexer_end.brace = 1;
		if (last->id != SEMI && last->id != LBRACE)
			control->lexer_end.add_semi = 1;
	}
	else if (brace[0] == brace[1])
		return (1);
	return (0);
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x2d3f
cmpl $0x0, 0x2c(%rsi)
jne 0x2d3f
movq (%rdi), %r8
movl 0x8(%r8), %r8d
cmpl $0x7, %r8d
je 0x2d2c
cmpl $0x6, %r8d
jne 0x2d2e
incl %ecx
jmp 0x2d2e
incl %eax
cmpl %eax, %ecx
jge 0x2d39
movl $0x7, 0x2c(%rsi)
movq 0x8(%rdi), %rdi
jmp 0x2d0a
cmpl %eax, %ecx
jle 0x2d62
movb 0x28(%rsi), %al
movl %eax, %ecx
orb $0x8, %cl
movb %cl, 0x28(%rsi)
movl 0x8(%rdx), %ecx
cmpl $0x1, %ecx
je 0x2d68
cmpl $0x6, %ecx
je 0x2d68
orb $0x18, %al
movb %al, 0x28(%rsi)
jmp 0x2d68
jne 0x2d68
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_signs_near_braces
int		lexer_signs_near_braces(t_list *tk_head, t_control *control)
{
	t_token		*prev_tk;
	t_token		*curr_tk;
	t_token		*next_tk;
	int			*signs;

	signs = (int	[]){LESS, DLESS, GREAT, DGREAT, AND, AND_IF, \
		PIPE, OR_IF, SEMI, -1};
	prev_tk = NULL;
	while (tk_head && !control->lexer_end.unexpected)
	{
		curr_tk = (t_token *)tk_head->content;
		next_tk = (tk_head->next ? (t_token *)tk_head->next->content : NULL);
		if (curr_tk->id == LBRACE && prev_tk &&
			lexer_tk_notbeside(curr_tk, prev_tk, (int *)signs, 1))
			control->lexer_end.unexpected = LBRACE;
		else if (curr_tk->id == RBRACE && next_tk &&
				lexer_tk_notbeside(curr_tk, next_tk, (int *)signs, 1))
			control->lexer_end.unexpected = RBRACE;
		prev_tk = (t_token *)tk_head->content;
		tk_head = tk_head->next;
	}
	return (control->lexer_end.unexpected ? 0 : 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups 0x831e(%rip), %xmm0     # 0xb0a4
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movups 0x82ff(%rip), %xmm0     # 0xb094
movaps %xmm0, (%r15)
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x20(%r15)
xorl %esi, %esi
pushq $0x1
popq %rbp
movl 0x2c(%rbx), %ecx
testq %r14, %r14
je 0x2e38
testl %ecx, %ecx
jne 0x2e38
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2dca
movq (%rax), %r12
jmp 0x2dcd
xorl %r12d, %r12d
movq (%r14), %r13
movl 0x8(%r13), %eax
cmpl $0x6, %eax
sete %cl
testq %rsi, %rsi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2dff
movq %r13, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2f86
pushq $0x6
popq %rcx
testl %eax, %eax
jne 0x2e29
movl 0x8(%r13), %eax
cmpl $0x7, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2e2c
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2f86
pushq $0x7
popq %rcx
testl %eax, %eax
je 0x2e2c
movl %ecx, 0x2c(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %r14
jmp 0x2dac
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_end
int		lexer_end(t_list *token_head, t_control *control)
{
	t_token	*last;

	if (token_head == NULL || (t_token *)(token_head->content) == NULL)
		return (0);
	last = (t_token *)(ft_lstlast(token_head)->content);
	if ((control->lexer_end.unexpected = lexer_forbidden_start(token_head)) ||
	(control->lexer_end.unexpected = lexer_forbidden_combo(token_head)))
		;
	else if (last->open_quote)
		control->lexer_end.quote = 1;
	else if (last->esc_next)
		control->lexer_end.backslash = 1;
	else if (last->id == AND_IF || last->id == PIPE || last->id == OR_IF)
		control->lexer_end.other = 1;
	else if (last->id == LESS || last->id == DLESS ||
			last->id == GREAT || last->id == DGREAT)
		control->lexer_end.unexpected = last->id;
	else if (ft_lstfind(token_head, (int	[]){LBRACE, RBRACE, -1},
			lexer_id_cmp) && !lexer_handle_braces(token_head, control, last))
		;
	else
		return (1);
	if (control->lexer_end.unexpected != 0)
		control->exit_status = (IS_APPLE ? 258 : 2);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2ecb
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x2ecb
movq %rsi, %rbx
movq %r14, %rdi
callq 0x9e40
movq (%rax), %r15
movq %r14, %rdi
callq 0x2fd6
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jne 0x2ec4
movq %r14, %rdi
callq 0x3087
movl %eax, 0x2c(%rbx)
testl %eax, %eax
je 0x2eda
movl $0x2, 0x4(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb 0x10(%r15), %al
testb $0x1, %al
jne 0x2efe
testb $0x2, %al
jne 0x2f04
movl 0x8(%r15), %eax
cmpl $0xd, %eax
ja 0x2f18
movl $0x3c00, %ecx           # imm = 0x3C00
btl %eax, %ecx
jae 0x2f0a
movl %eax, 0x2c(%rbx)
jmp 0x2ec4
orb $0x2, 0x28(%rbx)
jmp 0x2ecb
orb $0x4, 0x28(%rbx)
jmp 0x2ecb
pushq $0x2c
popq %rcx
btl %eax, %ecx
jae 0x2f18
orb $0x1, 0x28(%rbx)
jmp 0x2ecb
movabsq $0x700000006, %rax      # imm = 0x700000006
leaq 0xc(%rsp), %rsi
movq %rax, (%rsi)
orl $-0x1, 0x8(%rsi)
leaq -0x245(%rip), %rdx      # 0x2cf0
movq %r14, %rdi
callq 0x9e84
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x2ecd
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2e4e
testl %eax, %eax
jne 0x2ecd
cmpl $0x0, 0x2c(%rbx)
jne 0x2ec4
jmp 0x2ecb
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start_no_exceptions
int		lexer_forbidden_start_no_exceptions(t_list *token)
{
	t_token *curr_tk;
	t_token *next_tk;

	curr_tk = token->content;
	next_tk = (token->next ? token->next->content : NULL);
	if (next_tk && curr_tk->id == SEMI && next_tk->id == RBRACE)
		return (0);
	return (1);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2fd2
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2fd2
movq (%rdi), %rax
cmpl $0x1, 0x8(%rax)
jne 0x2fd2
xorl %eax, %eax
cmpl $0x7, 0x8(%rcx)
je 0x2fd5
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start
int		lexer_forbidden_start(t_list *tk_head)
{
	const int	*is_start = (int	[]){SEMI, LBRACE, PIPE, OR_IF, AND_IF, -1};
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND_IF, RBRACE, -1};

	if (lexer_tk_id_chr(forbidden, tk_head->content))
		return (((t_token *)tk_head->content)->id);
	while (tk_head)
	{
		if (lexer_forbidden_start_no_exceptions(tk_head))
			if (tk_head->next && lexer_tk_id_chr(is_start, tk_head->content) &&
					lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movups 0x80d3(%rip), %xmm0     # 0xb0bc
movaps %xmm0, (%rsp)
movabsq $-0xfffffffb, %rax      # imm = 0xFFFFFFFF00000005
movq %rax, 0x10(%rsp)
movups 0x80d1(%rip), %xmm0     # 0xb0d4
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movabsq $-0xfffffff9, %rax      # imm = 0xFFFFFFFF00000007
movq %rax, 0x10(%rdi)
movq (%rbx), %rsi
callq 0x2f6c
testl %eax, %eax
je 0x302d
movq (%rbx), %rax
movl 0x8(%rax), %eax
jmp 0x3077
movq %rsp, %r14
leaq 0x20(%rsp), %r15
testq %rbx, %rbx
je 0x3075
movq %rbx, %rdi
callq 0x2fb0
testl %eax, %eax
je 0x306f
cmpq $0x0, 0x8(%rbx)
je 0x306f
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2f6c
testl %eax, %eax
je 0x306f
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2f6c
testl %eax, %eax
jne 0x3081
movq 0x8(%rbx), %rbx
jmp 0x3035
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rbx
jmp 0x3025
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_combo
int		lexer_forbidden_combo(t_list *tk_head)
{
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND, AND_IF, RBRACE,
		LBRACE, LESS, DLESS, GREAT, DGREAT, -1};
	const int	*matter = (int	[]){LESS, DLESS, GREAT, DGREAT, -1};

	while (tk_head)
	{
		if (lexer_tk_id_chr(matter, tk_head->content))
		{
			if (tk_head->next \
					&& lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		}
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movups 0x8072(%rip), %xmm0     # 0xb10c
leaq 0x20(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movups 0x8051(%rip), %xmm0     # 0xb0fc
movaps %xmm0, 0x10(%r14)
movups 0x8035(%rip), %xmm0     # 0xb0ec
movaps %xmm0, (%r14)
movups 0x805a(%rip), %xmm0     # 0xb11c
movq %rsp, %r15
movaps %xmm0, (%r15)
orl $-0x1, 0x10(%r15)
testq %rbx, %rbx
je 0x3100
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2f6c
testl %eax, %eax
je 0x30fa
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x30fa
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2f6c
testl %eax, %eax
jne 0x3104
movq 0x8(%rbx), %rbx
jmp 0x30ce
xorl %eax, %eax
jmp 0x310e
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_builtin
int		env_builtin(t_list *env, t_control *control)
{
	while (env)
	{
		ft_putstr_fd(((t_env *)env->content)->label, 1);
		ft_putstr_fd("=", 1);
		ft_putendl_fd(((t_env *)env->content)->value, 1);
		env = env->next;
	}
	control->exit_status = 0;
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
leaq 0x8cd2(%rip), %r15      # 0xbe01
testq %r14, %r14
je 0x315f
movq (%r14), %rax
movq (%rax), %rdi
movl %ebp, %esi
callq 0x9668
movq %r15, %rdi
movl %ebp, %esi
callq 0x9668
movq (%r14), %rax
movq 0x8(%rax), %rdi
movl %ebp, %esi
callq 0x95cc
movq 0x8(%r14), %r14
jmp 0x312f
andl $0x0, 0x4(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_build_linked_list
t_list	*env_build_linked_list(char **env)
{
	t_list	*lst_head;
	t_list	*lst_link;
	t_env	*env_struct;
	int		i;

	i = 0;
	lst_head = NULL;
	while (env[i])
	{
		if (!(env_struct = env_build(env[i])))
		{
			ft_lstclear(&lst_head, env_del_struct);
			return (NULL);
		}
		if (!(lst_link = ft_lstnew(env_struct)))
		{
			env_del_struct(env_struct);
			ft_lstclear(&lst_head, env_del_struct);
			return (NULL);
		}
		ft_lstadd_back(&lst_head, lst_link);
		i++;
	}
	return (lst_head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31b9
callq 0x31e5
testq %rax, %rax
je 0x31c8
movq %rax, %r15
movq %rax, %rdi
callq 0x9e58
testq %rax, %rax
je 0x31c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x9dac
addq $0x8, %rbx
jmp 0x3186
movq 0x8(%rsp), %rax
jmp 0x31db
movq %r15, %rdi
callq 0x325f
leaq 0x90(%rip), %rsi        # 0x325f
leaq 0x8(%rsp), %rdi
callq 0x9de8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_build
t_env	*env_build(char *str)
{
	int		i;
	t_env	*new;

	if ((i = ft_strichr(str, '=')) == -1)
		return (NULL);
	if (!(new = env_init_struct()))
		return (NULL);
	if (!(new->label = ft_substr(str, 0, i++)) ||
		!(new->value = ft_substr(str + i, 0, ft_strlen(str + i))))
	{
		env_del_struct(new);
		return (NULL);
	}
	return (new);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x3d
popq %rsi
callq 0x9eb4
cmpl $-0x1, %eax
je 0x324f
movl %eax, %ebp
callq 0x327d
testq %rax, %rax
je 0x324f
movq %rax, %rbx
movslq %ebp, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x9d48
movq %rax, (%rbx)
testq %rax, %rax
je 0x3247
addq %r15, %r14
incq %r14
movq %r14, %rdi
callq 0x9be0
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x9d48
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x3251
movq %rbx, %rdi
callq 0x325f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_get
char	*env_get(char *str, size_t len, t_list *env)
{
	while (env)
	{
		if (((t_env*)env->content)->label)
		{
			if (ft_strlen(((t_env*)env->content)->label) == len \
					&& !ft_strncmp(str, ((t_env*)env->content)->label, len))
				return (((t_env*)env->content)->value);
		}
		env = env->next;
	}
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
testq %r14, %r14
je 0x32d4
movq (%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x32c7
callq 0x9be0
cmpq %r15, %rax
jne 0x32c7
movq (%r14), %rax
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x9bf8
testl %eax, %eax
je 0x32cd
movq 0x8(%r14), %r14
jmp 0x3298
movq (%r14), %rax
movq 0x8(%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_get_addr
char	**env_get_addr(char *str, size_t len, t_list *env)
{
	while (env)
	{
		if (((t_env *)env->content)->label)
		{
			if (ft_strlen(((t_env *)env->content)->label) == len \
					&& !ft_strncmp(str, ((t_env *)env->content)->label, len))
				return (&((t_env *)env->content)->value);
		}
		env = env->next;
	}
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
testq %r14, %r14
je 0x3332
movq (%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3325
callq 0x9be0
cmpq %r15, %rax
jne 0x3325
movq (%r14), %rax
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x9bf8
testl %eax, %eax
je 0x332b
movq 0x8(%r14), %r14
jmp 0x32f6
movq (%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_env.c
// Function: env_shlvl_update
int		env_shlvl_update(t_list **env, t_control *control)
{
	int		shlvl;
	char	*nbr;
	char	*argv[3];

	if (!(nbr = env_get("SHLVL", 5, *env)))
		nbr = "0";
	shlvl = ft_atoi(nbr) + 1;
	argv[0] = "export";
	argv[1] = NULL;
	argv[2] = NULL;
	if (!(nbr = ft_itoa(shlvl)) ||
		!(argv[1] = ft_strjoin_free("SHLVL=", nbr, 2)))
		return (0);
	export_builtin(env, argv, control);
	free(argv[1]);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x7dd5(%rip), %rdi      # 0xb130
pushq $0x5
popq %rsi
callq 0x3285
testq %rax, %rax
leaq 0x7f62(%rip), %rdi      # 0xb2cf
cmovneq %rax, %rdi
callq 0x9374
leal 0x1(%rax), %edi
leaq 0x7db6(%rip), %rax      # 0xb136
movq %rax, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x9490
xorl %ebp, %ebp
testq %rax, %rax
je 0x33cf
leaq 0x7da0(%rip), %rdi      # 0xb13d
pushq $0x2
popq %rdx
movq %rax, %rsi
callq 0x9b9c
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x33cf
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x355c
movq 0x8(%r15), %rdi
callq 0x2230
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_unset.c
// Function: unset_builtin
int		unset_builtin(t_list **env_head, char **argv, t_control *control)
{
	int i;

	i = 1;
	while (argv[i])
	{
		if (!is_identifier_valid(argv[i], "unset"))
			unset_in_env_list(env_head, argv[i]);
		else
			control->exit_status = 1;
		i++;
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
leaq 0x7d4c(%rip), %r12      # 0xb144
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3426
movq %r12, %rsi
callq 0x3435
testl %eax, %eax
je 0x3415
movl $0x1, 0x4(%rbx)
jmp 0x3420
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3478
addq $0x8, %r14
jmp 0x33f8
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_unset.c
// Function: unset_in_env_list
void	unset_in_env_list(t_list **env_head, char *str)
{
	t_list **ptr;
	t_list *extra;

	ptr = env_head;
	while (*ptr)
	{
		if (!ft_strncmp(str, ((t_env*)((*ptr)->content))->label, \
					ft_strlen(str) + 1))
		{
			extra = *ptr;
			*ptr = (*ptr)->next;
			env_del_struct(extra->content);
			free(extra);
			return ;
		}
		ptr = &(*ptr)->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x34cf
movq %rdi, %r15
movq (%rax), %rax
movq (%rax), %r14
movq %rbx, %rdi
callq 0x9be0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9bf8
movq (%r15), %r14
leaq 0x8(%r14), %rdi
testl %eax, %eax
jne 0x3480
movq 0x8(%r14), %rax
movq %rax, (%r15)
movq (%r14), %rdi
callq 0x325f
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2230
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_echo.c
// Function: echo_builtin
int	echo_builtin(char **argv, t_control *control)
{
	int i;
	int n_option;

	i = 1;
	while (argv[i] && argv[i][0] == '-' && ft_isonly(argv[i] + 1, 'n'))
		i++;
	n_option = (i == 1 ? 0 : 1);
	while (argv[i])
	{
		ft_putstr_fd(argv[i], 1);
		if (argv[++i])
			ft_putchar_fd(' ', 1);
	}
	if (!n_option)
		ft_putchar_fd('\n', 1);
	control->exit_status = 0;
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
xorl %r15d, %r15d
pushq $0x6e
popq %rbp
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3531
cmpb $0x2d, (%rdi)
jne 0x3531
incq %rdi
movl %ebp, %esi
callq 0x9424
testl %eax, %eax
je 0x3531
addq $0x8, %r14
decq %r15
jmp 0x34ef
pushq $0x1
popq %rsi
callq 0x9668
cmpq $0x0, (%r14)
je 0x352d
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x95b4
addq $0x8, %r14
movq -0x8(%r14), %rdi
testq %rdi, %rdi
jne 0x3514
testq %r15, %r15
jne 0x354a
pushq $0xa
popq %rdi
pushq $0x1
popq %rsi
callq 0x95b4
andl $0x0, 0x4(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin
int		export_builtin(t_list **head, char **argv, t_control *control)
{
	if (argv[1] == NULL)
		export_builtin_no_arg(head, control);
	else if (!export_builtin2(head, argv, control))
	{
		control->quit = 1;
		control->exit_status = errno;
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x3584
movq %rbx, %rdx
callq 0x3591
testl %eax, %eax
jne 0x358c
orb $0x1, (%rbx)
callq 0x2040
movl (%rax), %eax
movl %eax, 0x4(%rbx)
xorl %eax, %eax
jmp 0x358f
movq %rbx, %rsi
callq 0x3704
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin2
int		export_builtin2(t_list **head, char **argv, t_control *control)
{
	int		i;
	char	**str_addr;
	char	*sep2;

	i = 1;
	control->exit_status = 0;
	while (argv[i])
	{
		if (!(sep2 = export_builtin_check_label(argv[i], control)))
		{
			i++;
			continue;
		}
		if ((str_addr = env_get_addr(argv[i], ft_strlen(argv[i]), *head)))
		{
			ft_free((void **)str_addr);
			if (!(*str_addr = ft_strdup(sep2)))
				return (0);
		}
		else if (!export_builtin_new_env(argv[i], sep2, head))
			return (0);
		i++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
andl $0x0, 0x4(%rdx)
movq %rsi, %r15
movq %rdi, %r12
addq $0x8, %r15
pushq $0x1
popq %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x361f
movq %r14, %rsi
callq 0x3630
testq %rax, %rax
je 0x3617
movq %rax, %r13
movq (%r15), %rbp
movq %rbp, %rdi
callq 0x9be0
movq (%r12), %rdx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x32e3
testq %rax, %rax
je 0x3605
movq %rax, %rbp
movq %rax, %rdi
callq 0xa018
movq %r13, %rdi
callq 0x9aec
movq %rax, (%rbp)
testq %rax, %rax
jne 0x3617
jmp 0x361d
movq (%r15), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x367a
testl %eax, %eax
je 0x361d
addq $0x8, %r15
jmp 0x35b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin_check_label
char	*export_builtin_check_label(char *str, t_control *control)
{
	int i;

	if (is_identifier_valid(str, "export"))
	{
		control->exit_status = 1;
		return (NULL);
	}
	if ((i = ft_strichr(str, '=')) == -1)
		return (NULL);
	str[i] = '\0';
	return (str + i + 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7af5(%rip), %rsi      # 0xb136
callq 0x3435
testl %eax, %eax
je 0x3656
movl $0x1, 0x4(%r14)
xorl %eax, %eax
jmp 0x3672
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
je 0x3652
cltq
addq %rbx, %rax
incq %rax
movb $0x0, -0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq