LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: dbc_1st
static
int dbc_1st (BYTE c)
{
#if FF_CODE_PAGE == 0		/* Variable code page */
	if (DbcTbl && c >= DbcTbl[0]) {
		if (c <= DbcTbl[1]) return 1;					/* 1st byte range 1 */
		if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1;	/* 1st byte range 2 */
	}
#elif FF_CODE_PAGE >= 900	/* DBCS fixed code page */
	if (c >= DbcTbl[0]) {
		if (c <= DbcTbl[1]) return 1;
		if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1;
	}
#else						/* SBCS fixed code page */
	if (c != 0) return 0;	/* Always false */
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movzbl 0xe69(%rip), %ecx       # 0x749e
cmpl %ecx, %eax
jl 0x667a
movzbl -0x5(%rbp), %eax
movzbl 0xe5b(%rip), %ecx       # 0x749f
cmpl %ecx, %eax
jg 0x6651
movl $0x1, -0x4(%rbp)
jmp 0x6681
movzbl -0x5(%rbp), %eax
movzbl 0xe44(%rip), %ecx       # 0x74a0
cmpl %ecx, %eax
jl 0x6678
movzbl -0x5(%rbp), %eax
movzbl 0xe36(%rip), %ecx       # 0x74a1
cmpl %ecx, %eax
jg 0x6678
movl $0x1, -0x4(%rbp)
jmp 0x6681
jmp 0x667a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: dbc_2nd
static
int dbc_2nd (BYTE c)
{
#if FF_CODE_PAGE == 0		/* Variable code page */
	if (DbcTbl && c >= DbcTbl[4]) {
		if (c <= DbcTbl[5]) return 1;					/* 2nd byte range 1 */
		if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1;	/* 2nd byte range 2 */
		if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1;	/* 2nd byte range 3 */
	}
#elif FF_CODE_PAGE >= 900	/* DBCS fixed code page */
	if (c >= DbcTbl[4]) {
		if (c <= DbcTbl[5]) return 1;
		if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1;
		if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1;
	}
#else						/* SBCS fixed code page */
	if (c != 0) return 0;	/* Always false */
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movzbl 0xdfd(%rip), %ecx       # 0x74a2
cmpl %ecx, %eax
jl 0x6711
movzbl -0x5(%rbp), %eax
movzbl 0xdef(%rip), %ecx       # 0x74a3
cmpl %ecx, %eax
jg 0x66c1
movl $0x1, -0x4(%rbp)
jmp 0x6718
movzbl -0x5(%rbp), %eax
movzbl 0xdd8(%rip), %ecx       # 0x74a4
cmpl %ecx, %eax
jl 0x66e8
movzbl -0x5(%rbp), %eax
movzbl 0xdca(%rip), %ecx       # 0x74a5
cmpl %ecx, %eax
jg 0x66e8
movl $0x1, -0x4(%rbp)
jmp 0x6718
movzbl -0x5(%rbp), %eax
movzbl 0xdb3(%rip), %ecx       # 0x74a6
cmpl %ecx, %eax
jl 0x670f
movzbl -0x5(%rbp), %eax
movzbl 0xda5(%rip), %ecx       # 0x74a7
cmpl %ecx, %eax
jg 0x670f
movl $0x1, -0x4(%rbp)
jmp 0x6718
jmp 0x6711
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/checker/check.c
// Function: check
int	check(int *arr, int arr_size, t_list *instructions)
{
	t_deque			*stack[2];
	t_double_list	*cur;

	stack[0] = deque_init();
	stack[1] = deque_init();
	if (!stack[0] || !stack[1])
		error_exit();
	init_stack(stack[0], arr, arr_size);
	if (DEBUG == 1)
		display_stacks(stack, "Init a and b");
	sub(instructions, stack);
	if (stack[1]->size)
		return (0);
	cur = stack[0]->head;
	while (cur->next)
	{
		if (*((int *)cur->content) < *((int *)cur->next->content))
			return (0);
		cur = cur->next;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x3050
movq %rax, -0x30(%rbp)
callq 0x3050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11a3
cmpq $0x0, -0x28(%rbp)
jne 0x11a8
callq 0x17e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1c10
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1230
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x11d8
movl $0x0, -0x4(%rbp)
jmp 0x1224
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x121d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x120f
movl $0x0, -0x4(%rbp)
jmp 0x1224
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x11e3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/checker/check.c
// Function: sub
static void	sub(t_list *cur_instruction, t_deque *stack[2])
{
	while (cur_instruction)
	{
		assigned_operation(cur_instruction->content, stack);
		if (DEBUG == 1)
			display_stacks(stack, (char *)(cur_instruction->content));
		cur_instruction = cur_instruction->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1265
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: has_duplicate
int	has_duplicate(int *arr, int arrsize)
{
	int	ct[2];

	ct[0] = -1;
	while (++ct[0] < arrsize - 1)
	{
		ct[1] = ct[0];
		while (++ct[1] < arrsize)
		{
			if (arr[ct[0]] == arr[ct[1]])
				return (1);
		}
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x12ce
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x12cc
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x12ca
movl $0x1, -0x4(%rbp)
jmp 0x12d5
jmp 0x129b
jmp 0x1282
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: get_nbr_in_line
int	get_nbr_in_line(int **arr, int argc, char **argv)
{
	t_list	*lst;
	int		ct;

	lst = NULL;
	if (argc == 1)
		return (0);
	ct = 0;
	while (++ct < argc)
		put_in_list(&lst, argv[ct]);
	*arr = ft_malloc(ft_lstsize(lst), sizeof(int));
	if (!(*arr))
		error_exit();
	ct = 0;
	while (lst)
	{
		arr[0][ct++] = *((int *)(lst->content));
		lst = lst->next;
	}
	if (has_duplicate(arr[0], ct))
		error_exit();
	return (ct);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x130d
movl $0x0, -0x4(%rbp)
jmp 0x13c4
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x1339
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdi
callq 0x13d0
jmp 0x1314
movq -0x28(%rbp), %rdi
callq 0x24f0
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2530
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1368
callq 0x17e0
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13a5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq (%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 -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x136f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x1270
cmpl $0x0, %eax
je 0x13be
callq 0x17e0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: put_in_list
static void	put_in_list(t_list **lst, char *str)
{
	int	*temp;

	while (*str)
	{
		if (ft_isspace(*str))
			str++;
		else if (ft_isdigit(*str) || *str == '-' || *str == '+')
		{
			temp = ft_malloc(1, sizeof(int *));
			if (!temp)
				error_exit();
			*temp = ft_atoi_with_range(&str);
			ft_lstadd_back(lst, ft_lstnew((void *)temp));
		}
		else
			error_exit();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1490
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2ff0
cmpl $0x0, %eax
je 0x140c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x148b
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2120
cmpl $0x0, %eax
jne 0x1435
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1435
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x1484
movl $0x1, %edi
movl $0x8, %esi
callq 0x2530
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1454
callq 0x17e0
leaq -0x10(%rbp), %rdi
callq 0x1600
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x23b0
jmp 0x1489
callq 0x17e0
jmp 0x148b
jmp 0x13e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: check_instructions
void	check_instructions(char *str)
{
	if (!ft_strncmp(str, "sa", 3))
		return ;
	if (!ft_strncmp(str, "sb", 3))
		return ;
	if (!ft_strncmp(str, "ss", 3))
		return ;
	if (!ft_strncmp(str, "pa", 3))
		return ;
	if (!ft_strncmp(str, "pb", 3))
		return ;
	if (!ft_strncmp(str, "ra", 3))
		return ;
	if (!ft_strncmp(str, "rb", 3))
		return ;
	if (!ft_strncmp(str, "rr", 3))
		return ;
	if (!ft_strncmp(str, "rra", 4))
		return ;
	if (!ft_strncmp(str, "rrb", 4))
		return ;
	if (!ft_strncmp(str, "rrr", 4))
		return ;
	error_exit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b4d(%rip), %rsi      # 0x4004
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x14cb
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2b31(%rip), %rsi      # 0x4007
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x14ea
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2b15(%rip), %rsi      # 0x400a
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1509
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2af9(%rip), %rsi      # 0x400d
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1528
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2add(%rip), %rsi      # 0x4010
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1547
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2ac2(%rip), %rsi      # 0x4014
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1566
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2aa7(%rip), %rsi      # 0x4018
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1582
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2a8f(%rip), %rsi      # 0x401c
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x159e
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2a6a(%rip), %rsi      # 0x4013
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x15ba
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2a52(%rip), %rsi      # 0x4017
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x15d6
jmp 0x15f7
movq -0x8(%rbp), %rdi
leaq 0x2a3a(%rip), %rsi      # 0x401b
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x15f2
jmp 0x15f7
callq 0x17e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/utils.c
// Function: ft_atoi_with_range
int	ft_atoi_with_range(char **str)
{
	long long int	ct[3];

	sub(ct, str);
	while (str[0][++ct[0]])
	{
		if (!ft_isdigit(str[0][ct[0]]))
		{
			*str += ct[0];
			if (ft_isspace(str[0][0]))
				return (ct[1] * ct[2]);
			error_exit();
		}
		ct[1] = 10LL * ct[1] + str[0][ct[0]] - '0';
		if ((ct[2] == 1LL && ct[1] > 2147483647LL) || (ct[2] == -1LL && ct[1]
				> 2147483648LL) || (ct[1] == 0LL
				&& ft_isdigit(str[0][ct[0] + 1])))
			error_exit();
	}
	*str += ct[0];
	return (ct[1] * ct[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1720
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x16f9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2120
cmpl $0x0, %eax
jne 0x168b
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x2ff0
cmpl $0x0, %eax
je 0x1686
movq -0x28(%rbp), %rax
imulq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1713
callq 0x17e0
imulq $0xa, -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x30(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
subq $0x30, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x16bc
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jg 0x16ef
cmpq $-0x1, -0x20(%rbp)
jne 0x16ce
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, -0x28(%rbp)
jg 0x16ef
cmpq $0x0, -0x28(%rbp)
jne 0x16f4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %edi
callq 0x2120
cmpl $0x0, %eax
je 0x16f4
callq 0x17e0
jmp 0x1619
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
imulq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/utils.c
// Function: sub
static void	sub(long long ct[3], char **str)
{
	ct[0] = -1LL;
	if (str[0][0] == '+' || str[0][0] == '-')
		ct[0] = 0LL;
	ct[2] = 1LL;
	if (str[0][0] == '-')
		ct[2] = -1LL;
	ct[1] = 0LL;
	if ((str[0][0] == '-' || str[0][0] == '+') && !ft_isdigit(str[0][1]))
		error_exit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x1759
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1764
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x178b
movq -0x8(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x17b5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x17cf
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %edi
callq 0x2120
cmpl $0x0, %eax
jne 0x17cf
callq 0x17e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: sa
void	sa(t_deque *stack[2])
{
	void	*ptr[2];

	if (stack[0]->size > 1)
	{
		ptr[0] = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		ptr[1] = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		deque_push_back(stack[0], ptr[0]);
		deque_push_back(stack[0], ptr[1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x10(%rax)
jle 0x189d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x30b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x30b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: sb
void	sb(t_deque *stack[2])
{
	void	*ptr[2];

	if (stack[1]->size > 1)
	{
		ptr[0] = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		ptr[1] = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		deque_push_back(stack[1], ptr[0]);
		deque_push_back(stack[1], ptr[1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x10(%rax)
jle 0x1934
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x30b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x30b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: pa
void	pa(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size > 0)
	{
		ptr = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		deque_push_back(stack[0], ptr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x19be
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: pb
void	pb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size > 0)
	{
		ptr = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		deque_push_back(stack[1], ptr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1a1c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: ra
void	ra(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size == 0)
		return ;
	ptr = stack[0]->tail->content;
	deque_pop_back(stack[0], NULL);
	deque_push_front(stack[0], ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1a4b
jmp 0x1a7d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rb
void	rb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size == 0)
		return ;
	ptr = stack[1]->tail->content;
	deque_pop_back(stack[1], NULL);
	deque_push_front(stack[1], ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1aac
jmp 0x1ae1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rra
void	rra(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size == 0)
		return ;
	ptr = stack[0]->head->content;
	deque_pop_front(stack[0], NULL);
	deque_push_back(stack[0], ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1b3b
jmp 0x1b6c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3270
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rrb
void	rrb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size == 0)
		return ;
	ptr = stack[1]->head->content;
	deque_pop_front(stack[1], NULL);
	deque_push_back(stack[1], ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1b9c
jmp 0x1bd0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3270
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation3.c
// Function: init_stack
void	init_stack(t_deque *stack, int *arr, int arr_size)
{
	int	ct;

	ct = -1;
	while (++ct < arr_size)
		deque_push_front(stack, arr + ct);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x1c52
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x3140
jmp 0x1c2a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation3.c
// Function: assigned_operation
void	assigned_operation(void *ptr, t_deque *stack[2])
{
	char	*str;

	str = ptr;
	if (!ft_strncmp(str, "sa", 3))
		sa(stack);
	if (!ft_strncmp(str, "sb", 3))
		sb(stack);
	if (!ft_strncmp(str, "ss", 3))
		ss(stack);
	if (!ft_strncmp(str, "pa", 3))
		pa(stack);
	if (!ft_strncmp(str, "pb", 3))
		pb(stack);
	if (!ft_strncmp(str, "ra", 3))
		ra(stack);
	if (!ft_strncmp(str, "rb", 3))
		rb(stack);
	if (!ft_strncmp(str, "rr", 3))
		rr(stack);
	if (!ft_strncmp(str, "rra", 4))
		rra(stack);
	if (!ft_strncmp(str, "rrb", 4))
		rrb(stack);
	if (!ft_strncmp(str, "rrr", 4))
		rrr(stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2381(%rip), %rsi      # 0x4004
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1c9b
movq -0x10(%rbp), %rdi
callq 0x1820
movq -0x18(%rbp), %rdi
leaq 0x2361(%rip), %rsi      # 0x4007
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1cbe
movq -0x10(%rbp), %rdi
callq 0x18b0
movq -0x18(%rbp), %rdi
leaq 0x2341(%rip), %rsi      # 0x400a
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1ce1
movq -0x10(%rbp), %rdi
callq 0x1940
movq -0x18(%rbp), %rdi
leaq 0x2321(%rip), %rsi      # 0x400d
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1d04
movq -0x10(%rbp), %rdi
callq 0x1970
movq -0x18(%rbp), %rdi
leaq 0x2301(%rip), %rsi      # 0x4010
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1d27
movq -0x10(%rbp), %rdi
callq 0x19d0
movq -0x18(%rbp), %rdi
leaq 0x22e2(%rip), %rsi      # 0x4014
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1d4a
movq -0x10(%rbp), %rdi
callq 0x1a30
movq -0x18(%rbp), %rdi
leaq 0x22c3(%rip), %rsi      # 0x4018
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1d6d
movq -0x10(%rbp), %rdi
callq 0x1a90
movq -0x18(%rbp), %rdi
leaq 0x22a4(%rip), %rsi      # 0x401c
movl $0x3, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1d90
movq -0x10(%rbp), %rdi
callq 0x1af0
movq -0x18(%rbp), %rdi
leaq 0x2278(%rip), %rsi      # 0x4013
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1db3
movq -0x10(%rbp), %rdi
callq 0x1b20
movq -0x18(%rbp), %rdi
leaq 0x2259(%rip), %rsi      # 0x4017
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1dd6
movq -0x10(%rbp), %rdi
callq 0x1b80
movq -0x18(%rbp), %rdi
leaq 0x223a(%rip), %rsi      # 0x401b
movl $0x4, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x1df9
movq -0x10(%rbp), %rdi
callq 0x1be0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation4.c
// Function: display_stacks
void	display_stacks(t_deque *stack[2], char *message)
{
	int				ct[3];
	t_double_list	*cur[2];

	sub(ct, cur, message, stack);
	while (--ct[0] >= 0)
	{
		if (ct[0] < stack[0]->size)
		{
			display_number_width11(*((int *)cur[0]->content));
			cur[0] = cur[0]->last;
		}
		else
			ft_putstr_fd("           ", 1);
		ft_putstr_fd("     ", 1);
		if (ct[0] < stack[1]->size)
		{
			display_number_width11(*((int *)cur[1]->content));
			cur[1] = cur[1]->last;
		}
		ft_putendl_fd("", 1);
	}
	ft_putendl_fd("__________a     __________b", 1);
	ft_putendl_fd("---------------------------", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x1ef0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x1ec4
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1e62
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x1fb0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1e73
leaq 0x21bc(%rip), %rdi      # 0x4025
movl $0x1, %esi
callq 0x2350
leaq 0x21b1(%rip), %rdi      # 0x402b
movl $0x1, %esi
callq 0x2350
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1eae
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x1fb0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x221e(%rip), %rdi      # 0x40d3
movl $0x1, %esi
callq 0x2250
jmp 0x1e25
leaq 0x2166(%rip), %rdi      # 0x4031
movl $0x1, %esi
callq 0x2250
leaq 0x2171(%rip), %rdi      # 0x404d
movl $0x1, %esi
callq 0x2250
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation4.c
// Function: sub
static void	sub(int ct[3], t_double_list *cur[2],
char *message, t_deque *stack[2])
{
	ct[0] = ft_max(stack[0]->size, stack[1]->size);
	ct[2] = stack[0]->size + stack[1]->size - ct[0];
	ft_putendl_fd(message, 1);
	while (ct[2]-- > 0)
		ft_putendl_fd("", 1);
	cur[0] = stack[0]->tail;
	cur[1] = stack[1]->tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
callq 0x2fc0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
addl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
subl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2250
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x8(%rcx)
cmpl $0x0, %eax
jle 0x1f81
leaq 0x215e(%rip), %rdi      # 0x40d3
movl $0x1, %esi
callq 0x2250
jmp 0x1f5a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/share/operation4.c
// Function: display_number_width11
static void	display_number_width11(int num)
{
	int	ct[2];

	ct[0] = 1;
	if (num < 0)
		ct[0]++;
	ct[1] = num;
	while (ct[1] > 9 || ct[1] < -9)
	{
		ct[0]++;
		ct[1] /= 10;
	}
	ct[0] = 11 - ct[0];
	while (ct[0]--)
		ft_putchar_fd(' ', 1);
	ft_putnbr_fd(num, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x1fd1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movb $0x1, %al
cmpl $0x9, -0x8(%rbp)
movb %al, -0xd(%rbp)
jg 0x1fec
cmpl $-0x9, -0x8(%rbp)
setl %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1ff5
jmp 0x200e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
jmp 0x1fd7
movl $0xb, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x203a
movl $0x20, %edi
movl $0x1, %esi
callq 0x2220
jmp 0x2019
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x2290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/checker/main.c
// Function: main
int	main(int argc, char **argv)
{
	int		*arr;
	int		arr_size;
	t_list	*instructions;
	char	*line;

	arr_size = get_nbr_in_line(&arr, argc, argv);
	if (arr_size == 0)
		normal_exit();
	instructions = NULL;
	while (get_next_line(0, &line) == 1)
	{
		check_instructions(line);
		ft_lstadd_back(&instructions, ft_lstnew(line));
	}
	if (arr_size == 0)
		normal_exit();
	else if (check(arr, arr_size, instructions))
		ft_putendl_fd("OK", 1);
	else
		ft_putendl_fd("KO", 1);
	ft_free_all();
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x12e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2084
callq 0x1810
movq $0x0, -0x28(%rbp)
xorl %edi, %edi
leaq -0x30(%rbp), %rsi
callq 0x25b0
cmpl $0x1, %eax
jne 0x20bc
movq -0x30(%rbp), %rdi
callq 0x14a0
movq -0x30(%rbp), %rdi
callq 0x2480
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x23b0
jmp 0x208c
cmpl $0x0, -0x1c(%rbp)
jne 0x20c9
callq 0x1810
jmp 0x2104
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1170
cmpl $0x0, %eax
je 0x20f1
leaq 0x1f84(%rip), %rdi      # 0x4069
movl $0x1, %esi
callq 0x2250
jmp 0x2102
leaq 0x1f74(%rip), %rdi      # 0x406c
movl $0x1, %esi
callq 0x2250
jmp 0x2104
callq 0x2590
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_strncmp.c
// Function: ft_strncmp
int	ft_strncmp(const char *ss1, const char *ss2, size_t n)
{
	unsigned char	*s1;
	unsigned char	*s2;

	s1 = (unsigned char *)ss1;
	s2 = (unsigned char *)ss2;
	if (!s1 || !s2)
		return (0);
	if (n == 0)
		return (0);
	if (*s1 == 0 || *s2 == 0 || *s1 != *s2)
		return (*s1 - *s2);
	s1++;
	s2++;
	return (ft_strncmp((char *)(s1), (char *)(s2), n - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2182
cmpq $0x0, -0x30(%rbp)
jne 0x218b
movl $0x0, -0x4(%rbp)
jmp 0x220a
cmpq $0x0, -0x20(%rbp)
jne 0x219b
movl $0x0, -0x4(%rbp)
jmp 0x220a
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x21c5
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x21c5
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x21da
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x220a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
callq 0x2150
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char *s, int fd)
{
	if (!s || fd < 0)
		return ;
	ft_putstr_fd(s, fd);
	ft_putchar_fd('\n', fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x226c
cmpl $0x0, -0xc(%rbp)
jge 0x226e
jmp 0x2287
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2350
movl -0xc(%rbp), %esi
movl $0xa, %edi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_putnbr_fd.c
// Function: ft_putnbr_fd
void	ft_putnbr_fd(int n, int fd)
{
	if (fd < 0)
		return ;
	if (n == 0)
	{
		ft_putstr_fd("0", fd);
		return ;
	}
	else if (n == -2147483648)
	{
		ft_putstr_fd("-2147483648", fd);
		return ;
	}
	else if (n < 0)
		ft_putchar_fd('-', fd);
	if (n < 0)
		n /= -1;
	if (n > 9)
		ft_putnbr_fd(n / 10, fd);
	ft_putchar_fd('0' + n % 10, fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x22a9
jmp 0x233e
cmpl $0x0, -0x4(%rbp)
jne 0x22c0
movl -0x8(%rbp), %esi
leaq 0x1db6(%rip), %rdi      # 0x406f
callq 0x2350
jmp 0x233e
movslq -0x4(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x22dd
movl -0x8(%rbp), %esi
leaq 0x1d9b(%rip), %rdi      # 0x4071
callq 0x2350
jmp 0x233e
cmpl $0x0, -0x4(%rbp)
jge 0x22f0
movl -0x8(%rbp), %esi
movl $0x2d, %edi
callq 0x2220
jmp 0x22f2
jmp 0x22f4
cmpl $0x0, -0x4(%rbp)
jge 0x2308
movl -0x4(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x9, -0x4(%rbp)
jle 0x2323
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edi
movl -0x8(%rbp), %esi
callq 0x2290
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movl -0x8(%rbp), %esi
movsbl %al, %edi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_lstadd_back.c
// Function: ft_lstadd_back
int	ft_lstadd_back(t_list **lst, t_list *new)
{
	t_list	*temp;

	if (!new || !lst)
	{
		ft_putstr_fd("ERROR_IN_FT_LSTADD_BACK\n", 1);
		return (0);
	}
	temp = ft_lstlast(*lst);
	if (!temp)
	{
		*lst = new;
		return (1);
	}
	temp->next = new;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23ce
cmpq $0x0, -0x10(%rbp)
jne 0x23e8
leaq 0x1ca8(%rip), %rdi      # 0x407d
movl $0x1, %esi
callq 0x2350
movl $0x0, -0x4(%rbp)
jmp 0x2426
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2413
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2426
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_lstlast.c
// Function: ft_lstlast
t_list	*ft_lstlast(t_list *lst)
{
	t_list	*temp;

	temp = lst;
	if (!temp)
		return (NULL);
	while (temp->next)
		temp = temp->next;
	return (temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2451
movq $0x0, -0x8(%rbp)
jmp 0x2474
jmp 0x2453
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x246c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2453
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void *content)
{
	t_list	*nw;

	nw = (t_list *)ft_malloc(1, sizeof(t_list));
	if (!nw)
	{
		ft_putstr_fd("ERROR_IN_FT_LSTNEW\n", 1);
		return (NULL);
	}
	nw->content = content;
	nw->next = NULL;
	return (nw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x2530
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x24c1
leaq 0x1be9(%rip), %rdi      # 0x4096
movl $0x1, %esi
callq 0x2350
movq $0x0, -0x8(%rbp)
jmp 0x24e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_lstsize.c
// Function: ft_lstsize
int	ft_lstsize(t_list *lst)
{
	int		ans;
	t_list	*temp;

	ans = 0;
	temp = lst;
	while (temp)
	{
		ans++;
		temp = temp->next;
	}
	return (ans);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2525
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2507
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/get_next_line.c
// Function: get_next_line
int	get_next_line(int fd, char **line)
{
	char				buff[BUFFER_SIZE + 1];
	static t_lst		*save;
	t_lst				*temp;
	int					res[3];

	temp = save;
	while (temp && temp->fd != fd)
		temp = temp->next;
	if (!temp)
		temp = ft_lst_add(&save, fd);
	if (!temp || fd < 0 || BUFFER_SIZE < 1 || !line)
		return (-1);
	*line = 0;
	if (ft_check(temp, line, save))
		return (1);
	res[2] = fd;
	while (1)
	{
		ft_gnl((int *)res, buff, line, temp);
		if (res[0] == -1 || res[1] == -1)
			return (ft_del_lst(temp, &save, (int *)res));
		if (res[1] == 1 || res[1] == 2 || res[0] == 0)
			break ;
	}
	return (ft_del_lst(temp, &save, (int *)res));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3a8a(%rip), %rax      # 0x6050
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x48(%rbp)
movb %al, -0x55(%rbp)
je 0x25e6
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x8(%rbp), %eax
setne %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x25ef
jmp 0x25fd
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x25ca
cmpq $0x0, -0x48(%rbp)
jne 0x2617
movl -0x8(%rbp), %esi
leaq 0x3a42(%rip), %rdi      # 0x6050
callq 0x2ce0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x262b
cmpl $0x0, -0x8(%rbp)
jl 0x262b
cmpq $0x0, -0x10(%rbp)
jne 0x2637
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26d1
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x39ff(%rip), %rdx      # 0x6050
callq 0x26e0
cmpl $0x0, %eax
je 0x2664
movl $0x1, -0x4(%rbp)
jmp 0x26d1
movl -0x8(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x54(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x2840
cmpl $-0x1, -0x54(%rbp)
je 0x268b
cmpl $-0x1, -0x50(%rbp)
jne 0x26a4
movq -0x48(%rbp), %rdi
leaq -0x54(%rbp), %rdx
leaq 0x39b6(%rip), %rsi      # 0x6050
callq 0x2e10
movl %eax, -0x4(%rbp)
jmp 0x26d1
cmpl $0x1, -0x50(%rbp)
je 0x26b6
cmpl $0x2, -0x50(%rbp)
je 0x26b6
cmpl $0x0, -0x54(%rbp)
jne 0x26b8
jmp 0x26ba
jmp 0x266a
movq -0x48(%rbp), %rdi
leaq -0x54(%rbp), %rdx
leaq 0x3987(%rip), %rsi      # 0x6050
callq 0x2e10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/get_next_line.c
// Function: ft_check
static int	ft_check(t_lst *temp, char **line, t_lst *save)
{
	int	ct[3];

	if (temp->len > temp->idx && temp->str->s[temp->idx] == '\n')
	{
		(temp->idx)++;
		*line = ft_substr("", 0, 0);
		return (1);
	}
	ct[0] = -1;
	ct[1] = 0;
	while (++ct[0] + (temp->idx) < (temp->len))
		if (temp->str->s[ct[0] + temp->idx] == '\n')
			break ;
	if (ct[0] == 0)
		return (ft_clean_lst(temp));
	if (ct[0] + temp->idx < temp->len)
	{
		line[0] = ft_substr(temp->str->s, temp->idx, ct[0]);
		(temp->idx) += ct[0] + 1;
		if (temp->len == temp->idx)
			ft_del_lst(temp, &save, (int *)ct);
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x2755
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x2755
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
leaq 0x19a0(%rip), %rdi      # 0x40d3
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x34b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x282d
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x27a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
addl 0x10(%rdx), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x279e
jmp 0x27a0
jmp 0x2763
cmpl $0x0, -0x2c(%rbp)
jne 0x27b4
movq -0x10(%rbp), %rdi
callq 0x2d90
movl %eax, -0x4(%rbp)
jmp 0x282d
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2826
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x34b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x281d
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x2e10
movl $0x1, -0x4(%rbp)
jmp 0x282d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/get_next_line.c
// Function: ft_gnl
static void	ft_gnl(int *res, char *buff, char **line, t_lst *temp)
{
	res[0] = read(res[2], buff, BUFFER_SIZE);
	if (res[0] == -1)
	{
		res[1] = -1;
		return ;
	}
	buff[res[0]] = '\0';
	res[1] = ft_end(line, temp, res[0], (char *)buff);
	if (res[1] == 1 || res[1] == 2 || res[0] == 0)
		if (*line == 0)
			*line = ft_substr("", 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movl $0x2a, %edx
callq 0x1040
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x288b
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x2900
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rcx
callq 0x2910
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x28d7
movq -0x8(%rbp), %rax
cmpl $0x2, 0x4(%rax)
je 0x28d7
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2900
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x28fe
leaq 0x17eb(%rip), %rdi      # 0x40d3
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x34b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2900
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/get_next_line.c
// Function: ft_end
static int	ft_end(char **line, t_lst *temp, int res, char *buff)
{
	int	idx[3];

	if (res == 0 && temp->len == 0)
		return (1);
	idx[0] = 0;
	if (res && *buff == '\n' && ft_fill(line, temp) == -1)
		return (-1);
	else if (res && *buff == '\n')
		return (ft_str_add(temp, buff + 1, res - 1));
	while (idx[0] < res && buff[idx[0]] != '\n')
		idx[0]++;
	if (ft_str_add(temp, buff, idx[0]) == -1)
		return (-1);
	if (res != BUFFER_SIZE || idx[0] < res)
	{
		if (ft_fill(line, temp) == -1)
			return (-1);
		if (res == idx[0])
			return (2);
		return (ft_str_add(temp, buff + idx[0] + 1, res - idx[0] - 1));
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2943
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2943
movl $0x1, -0x4(%rbp)
jmp 0x2a6a
movl $0x0, -0x34(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x297a
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x297a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a80
cmpl $-0x1, %eax
jne 0x297a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a6a
cmpl $0x0, -0x1c(%rbp)
je 0x29ab
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x29ab
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
callq 0x2b80
movl %eax, -0x4(%rbp)
jmp 0x2a6a
jmp 0x29ad
jmp 0x29af
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x35(%rbp)
jge 0x29d1
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x29da
jmp 0x29e5
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29af
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x2b80
cmpl $-0x1, %eax
jne 0x2a03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a6a
cmpl $0x2a, -0x1c(%rbp)
jne 0x2a11
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2a63
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a80
cmpl $-0x1, %eax
jne 0x2a2c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a6a
movl -0x1c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x2a3d
movl $0x2, -0x4(%rbp)
jmp 0x2a6a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
movl -0x1c(%rbp), %edx
subl -0x34(%rbp), %edx
subl $0x1, %edx
callq 0x2b80
movl %eax, -0x4(%rbp)
jmp 0x2a6a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)