LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: get_as_compound_callback
static void _get_as_compound_callback(Mutator const * mutator,
		String const * key, void * value, void * data)
{
	VariableCompoundCallbackData * vccd = data;
	Variable const * from = value;
	VariableType type;
	size_t size;
	int res;
	(void) mutator;
	(void) key;

	/* XXX assumes alignment on byte boundary */
	type = variable_get_type(from);
	size = *(vccd->size);
	size = (size >= vccd->pos) ? size - vccd->pos : 0;
	if((res = variable_get_as(from, type, &vccd->result[vccd->pos], &size))
			!= 0)
		vccd->ret = res;
	vccd->pos += size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4820
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xec32
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x50(%rbp)
jmp 0xec3a
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xec3a
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
addq 0x10(%rax), %rdx
leaq -0x40(%rbp), %rcx
callq 0x4680
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0xec74
movl -0x44(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: copy_compound_foreach
static void _copy_compound_foreach(Mutator const * mutator, String const * key,
		void * value, void * data)
{
	Mutator ** m = (Mutator **)data;
	Variable * v = (Variable *)value;
	(void) mutator;

	if(*m == NULL)
		return;
	if(v == NULL)
		return;
	if((v = variable_new_copy(v)) == NULL
			|| mutator_set(*m, key, v) != 0)
	{
		variable_delete(v);
		*m = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf094
jmp 0xf0dd
cmpq $0x0, -0x30(%rbp)
jne 0xf09d
jmp 0xf0dd
movq -0x30(%rbp), %rdi
callq 0x4090
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xf0c9
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0xf0dd
movq -0x30(%rbp), %rdi
callq 0x4330
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/push_swap.c
// Function: display_instructions
void	display_instructions(t_deque *instructions, int *arr,
int arr_size, int fd)
{
	t_deque			*stack[2];
	t_double_list	*iter;

	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");
	iter = instructions->head;
	while (iter)
	{
		assigned_operation(iter->content, stack);
		if (DEBUG == 1)
			display_stacks(stack, iter->content);
		else
			ft_putendl_fd(iter->content, fd);
		iter = iter->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
callq 0x3520
movq %rax, -0x30(%rbp)
callq 0x3520
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11d6
cmpq $0x0, -0x28(%rbp)
jne 0x11db
callq 0x2400
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2830
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x122a
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2880
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x3000
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x11f6
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/push_swap.c
// Function: push_swap
t_deque	*push_swap(t_deque *stack[2])
{
	t_deque	*instructions;

	instructions = deque_init();
	if (check_order(stack))
		return (instructions);
	if (stack[0]->size <= 5)
		easy_solve(stack, instructions);
	else if (stack[0]->size <= 100)
		medium_solve(stack, instructions);
	else
		hard_solve(stack, instructions);
	return (instructions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x3520
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1320
cmpl $0x0, %eax
je 0x125d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, 0x10(%rax)
jg 0x1279
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13a0
jmp 0x12a4
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x64, 0x10(%rax)
jg 0x1295
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ba0
jmp 0x12a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18a0
jmp 0x12a4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/utils.c
// Function: descretize_stack
void	descretize_stack(t_deque *stack, int *arr, int arr_size)
{
	t_double_list	*temp;

	temp = stack->head;
	while (temp)
	{
		*((int *)temp->content) = binary_search(arr, arr_size,
				*((int *)temp->content));
		temp = temp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1313
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
callq 0x3a80
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12de
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/utils.c
// Function: check_order
int	check_order(t_deque *stack[2])
{
	int				ct;
	t_double_list	*temp;

	if (stack[1]->size != 0)
		return (0);
	ct = -1;
	temp = stack[0]->tail;
	while (++ct < stack[0]->size)
	{
		if (*((int *)temp->content) != ct)
			return (0);
		temp = temp->last;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x133f
movl $0x0, -0x4(%rbp)
jmp 0x1396
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x138f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x1381
movl $0x0, -0x4(%rbp)
jmp 0x1396
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1355
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/easy_solve.c
// Function: easy_solve
void	easy_solve(t_deque *stack[2], t_deque *instructions)
{
	char	*operation[11];

	assigned_operations(operation);
	if (exception(stack, instructions))
		return ;
	if (recursive(stack, instructions, operation, -1) == 0)
	{
		ft_putendl_fd("Unexpected error !!", 2);
		error_exit();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1410
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1520
cmpl $0x0, %eax
je 0x13cd
jmp 0x13fe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x1690
cmpl $0x0, %eax
jne 0x13fe
leaq 0x3c15(%rip), %rdi      # 0x5004
movl $0x2, %esi
callq 0x3000
callq 0x2400
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/easy_solve.c
// Function: assigned_operations
static void	assigned_operations(char *operation[11])
{
	operation[0] = ft_strdup("sa");
	operation[1] = ft_strdup("sb");
	operation[2] = ft_strdup("ss");
	operation[3] = ft_strdup("pa");
	operation[4] = ft_strdup("pb");
	operation[5] = ft_strdup("ra");
	operation[6] = ft_strdup("rb");
	operation[7] = ft_strdup("rr");
	operation[8] = ft_strdup("rra");
	operation[9] = ft_strdup("rrb");
	operation[10] = ft_strdup("rrr");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3bf5(%rip), %rdi      # 0x5018
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq 0x3be2(%rip), %rdi      # 0x501b
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x3bce(%rip), %rdi      # 0x501e
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x3bba(%rip), %rdi      # 0x5021
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x3ba6(%rip), %rdi      # 0x5024
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x3b93(%rip), %rdi      # 0x5028
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
leaq 0x3b80(%rip), %rdi      # 0x502c
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq 0x3b6d(%rip), %rdi      # 0x5030
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
leaq 0x3b4d(%rip), %rdi      # 0x5027
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
leaq 0x3b3a(%rip), %rdi      # 0x502b
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
leaq 0x3b27(%rip), %rdi      # 0x502f
callq 0x2e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/easy_solve.c
// Function: exception
static int	exception(t_deque *stack[2], t_deque *instructions)
{
	t_double_list	*temp;

	if (stack[0]->size != 5)
		return (0);
	temp = stack[0]->head;
	if (*((int *)temp->content) != 4)
		return (0);
	temp = temp->next;
	if (*((int *)temp->content) != 0)
		return (0);
	temp = temp->next;
	if (*((int *)temp->content) != 1)
		return (0);
	temp = temp->next;
	if (*((int *)temp->content) != 2)
		return (0);
	generate_instructions(stack, "sa", instructions);
	generate_instructions(stack, "pb", instructions);
	generate_instructions(stack, "rra", instructions);
	generate_instructions(stack, "sa", instructions);
	generate_instructions(stack, "pa", instructions);
	generate_instructions(stack, "rra", instructions);
	generate_instructions(stack, "rra", instructions);
	generate_instructions(stack, "sa", instructions);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, 0x10(%rax)
je 0x1549
movl $0x0, -0x4(%rbp)
jmp 0x1682
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
je 0x156f
movl $0x0, -0x4(%rbp)
jmp 0x1682
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0x1593
movl $0x0, -0x4(%rbp)
jmp 0x1682
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
je 0x15b7
movl $0x0, -0x4(%rbp)
jmp 0x1682
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0x15db
movl $0x0, -0x4(%rbp)
jmp 0x1682
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3a2e(%rip), %rsi      # 0x5018
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3a26(%rip), %rsi      # 0x5024
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3a15(%rip), %rsi      # 0x5027
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39f2(%rip), %rsi      # 0x5018
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39e7(%rip), %rsi      # 0x5021
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39d9(%rip), %rsi      # 0x5027
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39c5(%rip), %rsi      # 0x5027
callq 0x1160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39a2(%rip), %rsi      # 0x5018
callq 0x1160
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/easy_solve.c
// Function: recursive
static int	recursive(t_deque *stack[2],
t_deque *instructions, char *operation[11], int avoid)
{
	int	ct;

	if (check_order(stack))
		return (1);
	if (stack[0]->size + stack[1]->size == 3 && instructions->size >= 3)
		return (0);
	if (stack[0]->size + stack[1]->size == 4 && instructions->size >= 5)
		return (0);
	if (stack[0]->size + stack[1]->size == 5 && instructions->size >= 7)
		return (0);
	ct = -1;
	while (++ct < 11)
	{
		if (ct == avoid || (ct == 3 && stack[1]->size == 0)
			|| (ct == 4 && stack[0]->size == 0))
			continue ;
		generate_instructions(stack, operation[ct], instructions);
		if (recursive(stack, instructions, operation, inverse_operation(ct)))
			return (1);
		deque_pop_back(instructions, NULL);
		assigned_operation(operation[inverse_operation(ct)], stack);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1320
cmpl $0x0, %eax
je 0x16c1
movl $0x1, -0x4(%rbp)
jmp 0x1834
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addl 0x10(%rcx), %eax
cmpl $0x3, %eax
jne 0x16f1
movq -0x18(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jl 0x16f1
movl $0x0, -0x4(%rbp)
jmp 0x1834
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addl 0x10(%rcx), %eax
cmpl $0x4, %eax
jne 0x1721
movq -0x18(%rbp), %rax
cmpl $0x5, 0x10(%rax)
jl 0x1721
movl $0x0, -0x4(%rbp)
jmp 0x1834
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addl 0x10(%rcx), %eax
cmpl $0x5, %eax
jne 0x1751
movq -0x18(%rbp), %rax
cmpl $0x7, 0x10(%rax)
jl 0x1751
movl $0x0, -0x4(%rbp)
jmp 0x1834
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0xb, %eax
jge 0x182d
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x1799
cmpl $0x3, -0x28(%rbp)
jne 0x1786
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x1799
cmpl $0x4, -0x28(%rbp)
jne 0x179b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x179b
jmp 0x1758
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x1160
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
callq 0x1840
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl %eax, %ecx
callq 0x1690
cmpl $0x0, %eax
je 0x17f5
movl $0x1, -0x4(%rbp)
jmp 0x1834
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36a0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %edi
callq 0x1840
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x2880
jmp 0x1758
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/easy_solve.c
// Function: inverse_operation
static int	inverse_operation(int idx)
{
	int	inverse[11];

	inverse[0] = 0;
	inverse[1] = 1;
	inverse[2] = 2;
	inverse[3] = 4;
	inverse[4] = 3;
	inverse[5] = 8;
	inverse[6] = 9;
	inverse[7] = 10;
	inverse[8] = 5;
	inverse[9] = 6;
	inverse[10] = 7;
	return (inverse[idx]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x2, -0x28(%rbp)
movl $0x4, -0x24(%rbp)
movl $0x3, -0x20(%rbp)
movl $0x8, -0x1c(%rbp)
movl $0x9, -0x18(%rbp)
movl $0xa, -0x14(%rbp)
movl $0x5, -0x10(%rbp)
movl $0x6, -0xc(%rbp)
movl $0x7, -0x8(%rbp)
movslq -0x4(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/hard_solve.c
// Function: hard_solve
void	hard_solve(t_deque *stack[2], t_deque *instructions)
{
	int	move;
	int	now_move;

	move = 0;
	while ((1 << move) < stack[0]->size)
		++move;
	now_move = 0;
	while (now_move++ < move)
	{
		if (now_move == move && now_move % 2)
			final_move(stack, instructions, now_move - 1);
		else
			normal_move(stack, instructions, now_move - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x18d8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18b7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x1931
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x191c
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x191c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x1940
jmp 0x192f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x1a00
jmp 0x18df
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/hard_solve.c
// Function: final_move
static void	final_move(t_deque *stack[2], t_deque *instructions, int digit_move)
{
	int	cnt[2];

	cnt[0] = 0;
	cnt[1] = stack[0]->size;
	while (cnt[0]++ < cnt[1])
	{
		if ((*((int *)stack[0]->tail->content) >> digit_move) % 2 == 0)
			generate_instructions(stack, "pb", instructions);
		else
			generate_instructions(stack, "ra", instructions);
	}
	while (stack[1]->size > 0)
		generate_instructions(stack, "pa", instructions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl -0x18(%rbp), %eax
jge 0x19c5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x19af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x367c(%rip), %rsi      # 0x5024
callq 0x1160
jmp 0x19c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x366a(%rip), %rsi      # 0x5028
callq 0x1160
jmp 0x1967
jmp 0x19c7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x19eb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x363d(%rip), %rsi      # 0x5021
callq 0x1160
jmp 0x19c7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/hard_solve.c
// Function: normal_move
static void	normal_move(t_deque *stack[2], t_deque *instructions,
int digit_move)
{
	int	cnt[2];

	cnt[0] = 0;
	if (stack[0]->size > 0)
	{
		cnt[1] = stack[0]->size;
		while (cnt[0]++ < cnt[1])
		{
			if ((*((int *)stack[0]->tail->content) >> digit_move) % 2 == 0)
				generate_instructions(stack, "pb", instructions);
			else
				generate_instructions(stack, "ra", instructions);
		}
		while (stack[0]->size > 0)
			generate_instructions(stack, "pb", instructions);
	}
	else
		sub(stack, instructions, digit_move, cnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1abd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl -0x18(%rbp), %eax
jge 0x1a96
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1a80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x35ab(%rip), %rsi      # 0x5024
callq 0x1160
jmp 0x1a94
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3599(%rip), %rsi      # 0x5028
callq 0x1160
jmp 0x1a38
jmp 0x1a98
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1abb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3570(%rip), %rsi      # 0x5024
callq 0x1160
jmp 0x1a98
jmp 0x1ad1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x1c(%rbp), %rcx
callq 0x1ae0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/hard_solve.c
// Function: sub
static void	sub(t_deque *stack[2], t_deque *instructions,
int digit_move, int cnt[2])
{
	cnt[1] = stack[1]->size;
	while (cnt[0]++ < cnt[1])
	{
		if ((*((int *)stack[1]->tail->content) >> digit_move) % 2)
			generate_instructions(stack, "pa", instructions);
		else
			generate_instructions(stack, "rb", instructions);
	}
	while (stack[1]->size > 0)
		generate_instructions(stack, "pa", instructions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1b6e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1b58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x34d0(%rip), %rsi      # 0x5021
callq 0x1160
jmp 0x1b6c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x34c5(%rip), %rsi      # 0x502c
callq 0x1160
jmp 0x1b09
jmp 0x1b70
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1b94
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3494(%rip), %rsi      # 0x5021
callq 0x1160
jmp 0x1b70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/medium_solve.c
// Function: medium_solve
void	medium_solve(t_deque *stack[2], t_deque *instructions)
{
	int	group_size;
	int	idx;
	int	size;

	size = stack[0]->size;
	group_size = ft_sqrt(8 * size);
	idx = size;
	while (idx > 0)
	{
		solve(ft_max(0, idx - group_size), idx, stack, instructions);
		idx = ft_max(0, idx - group_size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
shll $0x3, %edi
callq 0x3b00
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x1c08
movl -0x18(%rbp), %esi
subl -0x14(%rbp), %esi
xorl %edi, %edi
callq 0x3490
movl %eax, %edi
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x1c10
movl -0x18(%rbp), %esi
subl -0x14(%rbp), %esi
xorl %edi, %edi
callq 0x3490
movl %eax, -0x18(%rbp)
jmp 0x1bd1
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/medium_solve.c
// Function: solve
static void	solve(int begin, int end,
t_deque *stack[2], t_deque *instructions)
{
	int	rotate_a;

	while (stack[1]->size < end - begin)
	{
		if (*((int *)stack[0]->tail->content) >= begin
			&& *((int *)stack[0]->tail->content) < end)
			generate_instructions(stack, "pb", instructions);
		else
			generate_instructions(stack, "ra", instructions);
	}
	if (end < stack[0]->size + stack[1]->size)
	{
		rotate_a = find_target_from_tail(end, stack[0]);
		if (rotate_a <= stack[0]->size - rotate_a)
			while (rotate_a-- > 0)
				generate_instructions(stack, "ra", instructions);
		else
			while (stack[0]->size - rotate_a++ > 0)
				generate_instructions(stack, "rra", instructions);
	}
	sub(end, stack, instructions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl -0x8(%rbp), %ecx
subl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1c91
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jl 0x1c7b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x1c7b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x33b0(%rip), %rsi      # 0x5024
callq 0x1160
jmp 0x1c8f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x339e(%rip), %rsi      # 0x5028
callq 0x1160
jmp 0x1c26
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
addl 0x10(%rdx), %ecx
cmpl %ecx, %eax
jge 0x1d39
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1d50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x1d01
jmp 0x1cd9
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x1cff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3330(%rip), %rsi      # 0x5028
callq 0x1160
jmp 0x1cd9
jmp 0x1d37
jmp 0x1d03
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
subl %ecx, %eax
cmpl $0x0, %eax
jle 0x1d35
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x32f9(%rip), %rsi      # 0x5027
callq 0x1160
jmp 0x1d03
jmp 0x1d37
jmp 0x1d39
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1db0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/medium_solve.c
// Function: find_target_from_tail
static int	find_target_from_tail(int target, t_deque *stack)
{
	t_double_list	*temp;
	int				cnt;

	temp = stack->tail;
	cnt = 0;
	while (temp)
	{
		if (*((int *)temp->content) == target)
			return (cnt);
		cnt++;
		temp = temp->last;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1da2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x1d8b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1da9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1d6e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/medium_solve.c
// Function: sub
static void	sub(int end, t_deque *stack[2], t_deque *instructions)
{
	int	rotate_b;

	while (stack[1]->size > 0)
	{
		rotate_b = find_target_from_tail(--end, stack[1]);
		if (rotate_b <= stack[1]->size - rotate_b)
			while (rotate_b-- > 0)
				generate_instructions(stack, "rb", instructions);
		else
			while (stack[1]->size - rotate_b++ > 0)
				generate_instructions(stack, "rrb", instructions);
		generate_instructions(stack, "pa", instructions);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1e7d
movl -0x4(%rbp), %edi
addl $-0x1, %edi
movl %edi, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1d50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0x10(%rcx), %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x1e2d
jmp 0x1e05
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x1e2b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3208(%rip), %rsi      # 0x502c
callq 0x1160
jmp 0x1e05
jmp 0x1e64
jmp 0x1e2f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
subl %ecx, %eax
cmpl $0x0, %eax
jle 0x1e62
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x31d0(%rip), %rsi      # 0x502b
callq 0x1160
jmp 0x1e2f
jmp 0x1e64
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x31ae(%rip), %rsi      # 0x5021
callq 0x1160
jmp 0x1dc3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/main.c
// Function: main
int	main(int argc, char **argv)
{
	int				*arr[3];
	t_deque			*stack[2];
	int				ct[2];
	t_deque			*instructions;

	ct[1] = get_nbr_in_line(arr, argc, argv);
	sub(ct, stack, arr);
	while (++ct[0] < ct[1])
		arr[1][ct[0]] = arr[0][ct[0]];
	arr[2] = ft_malloc(ct[1], sizeof(int));
	if (!arr[2])
		error_exit();
	ct[0] = -1;
	while (++ct[0] < ct[1])
		arr[2][ct[0]] = arr[0][ct[0]];
	ft_sort(arr[1], arr[1] + ct[1], ft_ascending);
	descretize_stack(stack[0], arr[1], ct[1]);
	instructions = push_swap(stack);
	display_instructions(instructions, arr[2], ct[1], 1);
	normal_exit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1f00
movl %eax, -0x44(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2d80
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
cmpl -0x44(%rbp), %eax
jge 0x2cd0
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2caa
movslq -0x44(%rbp), %rdi
movl $0x4, %esi
callq 0x33e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2cee
callq 0x2400
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
cmpl -0x44(%rbp), %eax
jge 0x2d1b
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2cf5
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x44(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0xb3b(%rip), %rdx       # 0x3870
callq 0x38b0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0x12c0
leaq -0x40(%rbp), %rdi
callq 0x1230
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x44(%rbp), %edx
movl $0x1, %ecx
callq 0x11a0
callq 0x2430
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/srcs/push_swap/main.c
// Function: sub
static void	sub(int ct[2], t_deque *stack[2], int *arr[3])
{
	if (ct[1] < 2)
		normal_exit();
	stack[0] = deque_init();
	stack[1] = deque_init();
	if (!stack[0] || !stack[1])
		error_exit();
	init_stack(stack[0], arr[0], ct[1]);
	arr[1] = ft_malloc(ct[1], sizeof(int));
	if (!arr[1])
		error_exit();
	ct[0] = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jge 0x2da3
callq 0x2430
callq 0x3520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x3520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2dd7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2ddc
callq 0x2400
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x2830
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x4, %esi
callq 0x33e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2e23
callq 0x2400
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_sort.c
// Function: ft_sort
void	ft_sort(int *head, int *tail, int (*cmp)(int, int))
{
	int		*arr;
	int		nbr;
	int		ct;

	if (!cmp)
		cmp = ft_ascending;
	arr = head;
	nbr = (int)(tail - head);
	ct = nbr;
	while (--ct >= 0)
		ft_deep(arr, ct, nbr, cmp);
	while (--nbr >= 1)
	{
		ft_swap(arr + nbr, arr);
		ft_deep(arr, 0, nbr, cmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x38d6
leaq -0x62(%rip), %rax       # 0x3870
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x3919
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x3960
jmp 0x38f6
jmp 0x391b
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, %eax
jl 0x3955
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3a50
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %esi, %esi
callq 0x3960
jmp 0x391b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_sort.c
// Function: ft_deep
static void	ft_deep(int *arr, int index, int nbr, int (*cmp)(int, int))
{
	int	temp_index;

	if (index * 2 + 1 >= nbr)
		return ;
	if (index * 2 + 2 >= nbr)
		temp_index = index * 2 + 1;
	else
	{
		if (cmp(arr[index * 2 + 1], arr[index * 2 + 2]))
			temp_index = index * 2 + 2;
		else
			temp_index = index * 2 + 1;
	}
	if (cmp(arr[temp_index], arr[index]))
		return ;
	ft_swap(arr + index, arr + temp_index);
	ft_deep(arr, temp_index, nbr, cmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll %eax
addl $0x1, %eax
cmpl -0x10(%rbp), %eax
jl 0x3988
jmp 0x3a44
movl -0xc(%rbp), %eax
shll %eax
addl $0x2, %eax
cmpl -0x10(%rbp), %eax
jl 0x39a2
movl -0xc(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39eb
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
shll %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %edi
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
shll %edx
addl $0x2, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %esi
callq *%rax
cmpl $0x0, %eax
je 0x39de
movl -0xc(%rbp), %eax
shll %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39e9
movl -0xc(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39eb
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,4), %edi
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
callq *%rax
cmpl $0x0, %eax
je 0x3a0e
jmp 0x3a44
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x3a50
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x3960
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/binary_search.c
// Function: binary_search
int	binary_search(int *arr, int arr_size, int target)
{
	int	lb;
	int	ub;
	int	mid;

	lb = -1;
	ub = arr_size;
	while (ub - lb > 1)
	{
		mid = (ub + lb) / 2;
		if (arr[mid] < target)
			lb = mid;
		else if (arr[mid] > target)
			ub = mid;
		else
			return (mid);
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
cmpl $0x1, %eax
jle 0x3af3
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jge 0x3acf
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3af1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jle 0x3ae7
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3aef
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3afa
jmp 0x3af1
jmp 0x3a9b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LeoFu9487[P]push_swap/libft/ft_sqrt.c
// Function: ft_sqrt
int	ft_sqrt(int n)
{
	long long	lb;
	long long	ub;
	long long	mid;

	if (n <= 1LL)
		return (n);
	lb = 0LL;
	ub = (long long)n;
	while (ub - lb > 1LL)
	{
		mid = (lb + ub) / 2LL;
		if (mid * mid <= (long long)n)
			lb = mid;
		else
			ub = mid;
	}
	return ((int)lb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq $0x1, %rax
jg 0x3b19
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b7a
movq $0x0, -0x10(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
cmpq $0x1, %rax
jle 0x3b73
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq -0x20(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jg 0x3b69
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3b71
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b29
movq -0x10(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch6/track_memory.c
// Function: alloc
void *alloc(void *ud,
            void *ptr,
            size_t osize,
            size_t nsize) {
  bytes_alloced += nsize - (ptr ? osize : 0);
  if (nsize) return realloc(ptr, nsize);
  free(ptr);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5611
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5619
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x5619
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq 0x3bc75(%rip), %rax     # 0x412a0
movq %rax, 0x3bc6e(%rip)     # 0x412a0
cmpq $0x0, -0x28(%rbp)
je 0x564c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5390
movq %rax, -0x8(%rbp)
jmp 0x565d
movq -0x18(%rbp), %rdi
callq 0x5040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg.c
// Function: init
extern image_type_t *init(void)
{
	static image_type_t jpeg;
	jpeg.type = "JPEG";
	jpeg.is_type = is_jpeg;
	jpeg.read = read_jpeg;
	jpeg.write = write_jpeg;
	jpeg.info = info_jpeg;
	jpeg.free = free_jpeg;
	return &jpeg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5dc5(%rip), %rax      # 0x7000
movq %rax, 0x8296(%rip)      # 0x94d8
leaq 0x57(%rip), %rax        # 0x12a0
movq %rax, 0x8290(%rip)      # 0x94e0
leaq 0xc9(%rip), %rax        # 0x1320
movq %rax, 0x828a(%rip)      # 0x94e8
leaq 0x47b(%rip), %rax       # 0x16e0
movq %rax, 0x8284(%rip)      # 0x94f0
leaq 0x71d(%rip), %rax       # 0x1990
movq %rax, 0x827e(%rip)      # 0x94f8
leaq 0x77f(%rip), %rax       # 0x1a00
movq %rax, 0x8278(%rip)      # 0x9500
leaq 0x8249(%rip), %rax      # 0x94d8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg.c
// Function: is_jpeg
static bool is_jpeg(char *file_name)
{
	FILE *fp = fopen(file_name, "rb");
	if (!fp)
		return false;

	uint8_t header[3];
	fread(header, 1, sizeof header, fp);
	fclose(fp);

	return !memcmp(header, jpeg_header, sizeof header);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5d4e(%rip), %rsi      # 0x7005
callq 0x1100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12cd
movb $0x0, -0x1(%rbp)
jmp 0x130f
leaq -0x1b(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x3, %edx
callq 0x1060
movq -0x18(%rbp), %rdi
callq 0x1070
leaq -0x1b(%rbp), %rdi
leaq 0x5d18(%rip), %rsi      # 0x7010
movl $0x3, %edx
callq 0x10c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg.c
// Function: info_jpeg
extern uint64_t info_jpeg(image_info_t *image_info)
#endif
{
	data_info_t extra = { NULL, 0, true, false };
	image_info->extra = &extra;
	read_jpeg(image_info, NULL);
	return HIDE_CAPACITY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5675(%rip), %rax      # 0x7018
movq %rax, -0x20(%rbp)
movq 0x5672(%rip), %rax      # 0x7020
movq %rax, -0x18(%rbp)
movq 0x566f(%rip), %rax      # 0x7028
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1320
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
imulq 0x28(%rcx), %rax
subq $0x8, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg.c
// Function: free_jpeg
extern void free_jpeg(image_info_t image_info)
#endif
{
	free(image_info.buffer[0]);
	free(image_info.buffer);
	jpeg_image_t *image = image_info.extra;
	for (uint64_t i = 0; i < image->height; i++)
		free(image->rgb[i]);
	free(image->rgb);
	free(image);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40(%rax), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jae 0x1a6f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a3d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: JpegParseHeader
static int JpegParseHeader(stJpegData *jdata, const uint8_t *buf)
{
	// Identify the file
	if ((buf[0] != 0xFF) || (buf[1] != SOI))
	{
		fprintf(stderr, "Fail @ %s:%d\n", __FILE__, __LINE__);
		exit(-1);
	}
	const uint8_t *startStream = buf + 2;
	return ParseJFIF(jdata, startStream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x1c9d
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xd8, %eax
je 0x1ccb
movq 0x7354(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x5442(%rip), %rsi      # 0x70f0
leaq 0x5449(%rip), %rdx      # 0x70fe
movl $0x241, %ecx            # imm = 0x241
movb $0x0, %al
callq 0x10e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1150
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1eb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: ParseSOF
static int ParseSOF(stJpegData *jdata, const uint8_t *stream)
{
	/*
	 * SOF          16              0xffc0          Start Of Frame
	 * Lf           16              3Nf+8           Frame header length
	 * P            8               8                       Sample precision
	 * Y            16              0-65535         Number of lines
	 * X            16              1-65535         Samples per line
	 * Nf           8               1-255           Number of image components (e.g. Y, U and V).
	 *
	 * ---------Repeats for the number of components (e.g. Nf)-----------------
	 * Ci           8               0-255           Component identifier
	 * Hi           4               1-4                     Horizontal Sampling Factor
	 * Vi           4               1-4                     Vertical Sampling Factor
	 * Tqi          8               0-3                     Quantization Table Selector.
	 */

	int height = BYTE_TO_WORD(stream + 3);
	int width = BYTE_TO_WORD(stream + 5);
	int nr_components = stream[7];

	stream += 8;
	for (int i = 0; i < nr_components; i++)
	{
		int cid = *stream++;
		int sampling_factor = *stream++;
		int Q_table = *stream++;

		stComponent *c = &jdata->m_component_info[cid];
		c->m_vFactor = sampling_factor & 0xf;
		c->m_hFactor = sampling_factor >> 4;
		c->m_qTable = jdata->m_Q_tables[Q_table];
	}
	jdata->m_width = width;
	jdata->m_height = height;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x21c4
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movslq -0x24(%rbp), %rcx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %ecx
andl $0xf, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x28(%rbp), %ecx
sarl $0x4, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x2c0, %rcx            # imm = 0x2C0
movslq -0x2c(%rbp), %rax
shlq $0x9, %rax
addq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x211a
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)