LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_compare_length
int string_compare_length(String const * string, String const * string2,
		size_t length)
{
	int ret;
	unsigned char const * u1;
	unsigned char const * u2;

	if(length == 0)
		return 0;
	u1 = (unsigned char const *)string;
	u2 = (unsigned char const *)string2;
	while(--length && *u1 && *u2 && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	ret = *u1 - *u2;
	return ret;
}

// Assembly:
testq %rdx, %rdx
je 0x81ba
leaq (%rsi,%rdx), %rcx
decq %rcx
decq %rdx
xorl %eax, %eax
cmpq %rax, %rdx
je 0x81bd
movb (%rdi,%rax), %r8b
testb %r8b, %r8b
je 0x81c3
cmpb (%rsi,%rax), %r8b
jne 0x81c6
incq %rax
jmp 0x81a1
xorl %eax, %eax
retq
movb (%rdi,%rdx), %r8b
jmp 0x81cc
xorl %r8d, %r8d
addq %rax, %rsi
movq %rsi, %rcx
movzbl %r8b, %eax
movzbl (%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_explode
StringArray * string_explode(String const * string, String const * separator)
{
	StringArray * ret;
	String * p;			/* temporary pointer */
	size_t i;			/* current position */
	String const * s;		/* &string[i] */
	ssize_t j;			/* position of the next separator */
	ssize_t l;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\", \"%s\")\n", __func__, string,
			separator);
#endif
	if((ret = stringarray_new()) == NULL)
		return NULL;
	if(separator == NULL || (l = string_get_length(separator)) == 0)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		array_delete(ret);
		return NULL;
	}
	for(i = 0;; i += j + l)
	{
		s = &string[i];
		j = string_index(s, separator);
#ifdef DEBUG
		fprintf(stderr, "DEBUG: %s(): i=%zu, j=%zd\n", __func__, i, j);
#endif
		if(j < 0)
		{
			if((p = string_new(s)) == NULL
					|| array_append(ret, p) != 0)
			{
				string_delete(p);
				break;
			}
#ifdef DEBUG
			fprintf(stderr, "DEBUG: %s(): \"%s\"\n", __func__,
					ret[ret_cnt - 1]);
#endif
			return ret;
		}
		if((p = string_new_length(s, j)) == NULL
				|| array_append(ret, p) != 0)
		{
			string_delete(p);
			break;
		}
#ifdef DEBUG
		fprintf(stderr, "DEBUG: %s(): \"%s\"\n", __func__,
				ret[ret_cnt - 1]);
#endif
	}
	/* free everything */
	array_foreach(ret, _explose_foreach_delete, NULL);
	array_delete(ret);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
pushq $0x8
popq %rdi
callq 0x45f0
testq %rax, %rax
je 0x82b7
movq %rax, %rbx
testq %r14, %r14
je 0x8259
movq %r14, %rdi
callq 0x4350
testq %rax, %rax
je 0x8259
movq %rax, %r12
xorl %r15d, %r15d
movq (%rsp), %rax
leaq (%rax,%r15), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
testq %rax, %rax
js 0x8277
movq %rax, %rbp
movq %r13, %rdi
movq %rax, %rsi
callq 0x41d0
movq %rax, %r13
testq %rax, %rax
je 0x8296
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
jne 0x8296
addq %r12, %r15
addq %rbp, %r15
jmp 0x8214
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x2df6(%rip), %rsi      # 0xb05e
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
jmp 0x82af
movq %r13, %rdi
callq 0x41f0
movq %rax, %r13
testq %rax, %rax
je 0x8296
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
je 0x82b9
movq %r13, %rdi
callq 0x44a0
leaq 0x91(%rip), %rsi        # 0x8336
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4040
movq %rbx, %rdi
callq 0x44c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_index
ssize_t string_index(String const * string, String const * key)
{
	size_t len;
	size_t keylen;
	size_t i;

	len = string_get_length(string);
	if((keylen = string_get_length(key)) == 0)
		return len;
	if(keylen > len)
		return -1;
	for(i = 0; i <= len - keylen; i++)
		if(string_compare_length(&string[i], key, keylen) == 0)
			return i;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4350
movq %rax, %r12
movq %rbx, %rdi
callq 0x4350
testq %rax, %rax
je 0x831c
movq %rax, %r13
pushq $-0x1
popq %r15
subq %rax, %r12
jb 0x8324
xorl %ebp, %ebp
cmpq %r12, %rbp
ja 0x8324
leaq (%r14,%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x44f0
testl %eax, %eax
je 0x8321
incq %rbp
jmp 0x82ff
movq %r12, %r15
jmp 0x8324
movq %rbp, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_ltrim
size_t string_ltrim(String * string, String const * which)
{
	size_t i;
	size_t j;

	for(i = 0; string[i] != '\0'; i++)
		if(which == NULL)
		{
			if(!isspace((unsigned char)string[i]))
				break;
		}
		else
		{
			for(j = 0; which[j] != '\0' && string[i] != which[j];
					j++);
			if(which[j] == '\0')
				break;
		}
	for(j = i; string[j] != '\0'; j++)
		string[j - i] = string[j];
	string[j - i] = '\0';
	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movzbl (%r14,%rbx), %r12d
testq %r12, %r12
je 0x83a7
movq %r15, %rax
testq %r15, %r15
je 0x8387
movb (%rax), %cl
testb %cl, %cl
je 0x83a7
incq %rax
cmpb %cl, %r12b
jne 0x8377
jmp 0x8397
callq 0x4870
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x83a7
incq %rbx
jmp 0x8365
movb %r12b, (%r14)
movb 0x1(%r14,%rbx), %r12b
incq %r14
testb %r12b, %r12b
jne 0x839c
movb $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_rindex
ssize_t string_rindex(String const * string, String const * key)
{
	size_t len;
	size_t keylen;
	ssize_t i;

	len = string_get_length(string);
	if((keylen = string_get_length(key)) == 0)
		return len;
	if(keylen > len)
		return -1;
	for(i = len - keylen; i >= 0; i--)
		if(string_compare_length(&string[i], key, keylen) == 0)
			return i;
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4350
movq %rax, %r15
movq %rbx, %rdi
callq 0x4350
testq %rax, %rax
je 0x840c
movq %rax, %r13
pushq $-0x1
popq %r12
subq %rax, %r15
jb 0x840f
testq %r15, %r15
js 0x840f
leaq (%r14,%r15), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x44f0
testl %eax, %eax
je 0x840c
decq %r15
jmp 0x83ef
movq %r15, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_rtrim
size_t string_rtrim(String * string, String const * which)
{
	size_t ret = 0;
	size_t i;
	size_t j;

	for(i = string_get_length(string); i > 0; i--)
		if(which == NULL)
		{
			if(!isspace((unsigned char)string[i - 1]))
				return ret;
			string[i - 1] = '\0';
			ret++;
		}
		else
		{
			for(j = 0; which[j] != '\0'; j++)
				if(string[i - 1] == which[j])
				{
					string[i - 1] = '\0';
					ret++;
					break;
				}
			if(which[j] == '\0')
				break;
		}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4350
movq %rax, %r12
xorl %ebx, %ebx
movq %rax, %r13
subq $0x1, %r13
jb 0x848b
movq %r14, %rax
testq %r14, %r14
je 0x8458
movb (%rax), %cl
testb %cl, %cl
je 0x848b
cmpb %cl, -0x1(%r15,%r12)
je 0x8478
incq %rax
jmp 0x8446
callq 0x4870
movq (%rax), %rax
movzbl -0x1(%r15,%r12), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x848b
movb $0x0, -0x1(%r15,%r12)
incq %rbx
jmp 0x8486
movb $0x0, -0x1(%r15,%r12)
incq %rbx
cmpb $0x0, (%rax)
je 0x848b
movq %r13, %r12
jmp 0x8438
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/token.c
// Function: token_new
Token * token_new(String const * filename, unsigned int line, unsigned int col)
{
	Token * token;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%u, %u)\n", __func__, line, col);
#endif
	if((token = (Token *)object_new(sizeof(*token))) == NULL)
		return NULL;
	token->code = 0;
	token->string = NULL;
	token->filename = (filename != NULL) ? string_new(filename) : NULL;
	token->line = line;
	token->col = col;
	token->data = NULL;
	if(filename != NULL && token->filename == NULL)
	{
		error_set_code(1, "%s", strerror(errno));
		object_delete(token);
		return NULL;
	}
	return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x4620
testq %rax, %rax
je 0x85b6
movq %rax, %rbx
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
testq %r15, %r15
je 0x856a
movq %r15, %rdi
callq 0x41f0
jmp 0x856c
xorl %eax, %eax
testq %r15, %r15
setne %cl
movq %rax, 0x10(%rbx)
movl %r14d, 0x18(%rbx)
movl %ebp, 0x1c(%rbx)
andq $0x0, 0x20(%rbx)
testq %rax, %rax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x85b8
callq 0x40e0
movl (%rax), %edi
callq 0x47f0
leaq 0x2abd(%rip), %rsi      # 0xb05e
pushq $0x1
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_newv
Variable * variable_newv(VariableType type, va_list ap)
{
	Variable * variable;

	if((variable = (Variable *)object_new(sizeof(*variable))) == NULL)
		return NULL;
	variable->type = VT_NULL;
	if(variable_set_typev(variable, type, ap) != 0)
	{
		object_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0x20
popq %rdi
callq 0x4620
testq %rax, %rax
je 0x8745
movq %rax, %rbx
andl $0x0, (%rax)
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4130
testl %eax, %eax
je 0x8747
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_arrayv
Variable * variable_new_arrayv(VariableType type, size_t size, va_list ap)
{
	Variable * variable;
	size_t i;
	void * p;

	if((variable = variable_new(VT_ARRAY, type, size)) == NULL)
		return NULL;
	for(i = 0; i < size; i++)
	{
		p = va_arg(ap, void *);
		if(array_set(variable->u.array.array, i, p) != 0)
		{
			variable_delete(variable);
			return NULL;
		}
	}
	return variable;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %esi
pushq $0xe
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x46c0
testq %rax, %rax
je 0x8b86
movq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x8b89
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x8b5c
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x8b68
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rdx
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x4530
incq %r12
testl %eax, %eax
je 0x8b41
movq %r15, %rdi
callq 0x4330
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_compoundv
Variable * variable_new_compoundv(String const * name, va_list ap)
{
	Variable * variable;
	VariableType type;
	Mutator * m;
	Variable * v;

	if((variable = variable_new(VT_COMPOUND, name)) == NULL)
		return NULL;
	m = variable->u.compound.members;
	for(;;)
	{
		type = (VariableType)va_arg(ap, unsigned int);
		if(type == VT_NULL)
			return variable;
		name = va_arg(ap, String const *);
		if(name == NULL)
			break;
		if((v = (Variable *)mutator_get(m, name)) != NULL)
			variable_delete(v);
		if((v = variable_newv(type, ap)) == NULL
				|| mutator_set(m, name, v) != 0)
		{
			variable_delete(v);
			break;
		}
	}
	variable_delete(variable);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rsi
pushq $0xf
popq %rdi
xorl %eax, %eax
callq 0x46c0
testq %rax, %rax
je 0x8d04
movq %rax, %rbx
movq 0x18(%rax), %r15
movl (%r14), %eax
cmpq $0x28, %rax
ja 0x8c7b
movq %rax, %rcx
addq 0x10(%r14), %rcx
addl $0x8, %eax
movl %eax, (%r14)
jmp 0x8c87
movq 0x8(%r14), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl (%rcx), %ebp
testl %ebp, %ebp
je 0x8d06
cmpl $0x28, %eax
ja 0x8ca0
movl %eax, %ecx
addq 0x10(%r14), %rcx
addl $0x8, %eax
movl %eax, (%r14)
jmp 0x8cac
movq 0x8(%r14), %rcx
leaq 0x8(%rcx), %rax
movq %rax, 0x8(%r14)
movq (%rcx), %r12
testq %r12, %r12
je 0x8cfc
movq %r15, %rdi
movq %r12, %rsi
callq 0x45a0
testq %rax, %rax
je 0x8ccc
movq %rax, %rdi
callq 0x4330
movl %ebp, %edi
movq %r14, %rsi
callq 0x4370
movq %rax, %r13
testq %rax, %rax
je 0x8cf4
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x44e0
testl %eax, %eax
je 0x8c63
movq %r13, %rdi
callq 0x4330
movq %rbx, %rdi
callq 0x4330
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_compound_variables
Variable * variable_new_compound_variables(String const * name, size_t members,
		String const ** names, Variable const ** variables)
{
	Variable * variable;
	Mutator * m;
	size_t i;
	Variable * v;

	if((variable = variable_new(VT_COMPOUND, name)) == NULL)
		return NULL;
	m = variable->u.compound.members;
	for(i = 0; i < members; i++)
	{
		if(names[i] == NULL)
		{
			error_set_code(-EINVAL, "%s", strerror(EINVAL));
			break;
		}
		if((v = (Variable *)mutator_get(m, names[i])) != NULL)
		{
			mutator_set(m, names[i], NULL);
			variable_delete(v);
		}
		if((v = variable_new_copy(variables[i])) == NULL
				|| mutator_set(m, names[i], v) != 0)
			break;
	}
	if(i != members)
	{
		variable_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rsi
pushq $0xf
popq %rdi
xorl %eax, %eax
callq 0x46c0
testq %rax, %rax
je 0x8dd6
movq %rax, (%rsp)
movq 0x18(%rax), %r13
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x8dc7
movq (%r12,%rbx,8), %rsi
testq %rsi, %rsi
je 0x8da6
movq %r13, %rdi
callq 0x45a0
testq %rax, %rax
je 0x8d80
movq %rax, %rbp
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x44e0
movq %rbp, %rdi
callq 0x4330
movq (%r15,%rbx,8), %rdi
callq 0x40a0
testq %rax, %rax
je 0x8dc2
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
movq %rax, %rdx
callq 0x44e0
testl %eax, %eax
jne 0x8dc2
incq %rbx
jmp 0x8d4c
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x22a9(%rip), %rsi      # 0xb05e
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
cmpq %rbx, %r14
jne 0x8dcd
movq (%rsp), %rax
jmp 0x8dd8
movq (%rsp), %rdi
callq 0x4330
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_deserialize
Variable * variable_new_deserialize(size_t * size, char const * data)
{
	Variable * variable;
	uint8_t u8;
	VariableType type;
	size_t s;

	/* check the arguments */
	if(size == NULL || *size < sizeof(u8) || data == NULL)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		return NULL;
	}
	/* obtain the type from the data */
	u8 = data[0];
	type = (VariableType)u8;
	s = *size - sizeof(u8);
	/* deserialize according to the type */
	variable = variable_new_deserialize_type(type, &s, &data[sizeof(u8)]);
	*size = s + sizeof(u8);
	return variable;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x8faf
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
setne %cl
testq %rsi, %rsi
setne %sil
testb %cl, %sil
jne 0x8fd0
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x20a0(%rip), %rsi      # 0xb05e
xorl %r14d, %r14d
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
jmp 0x8ff5
movzbl (%rdx), %edi
decq %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
incq %rdx
movq %r15, %rsi
callq 0x40f0
movq %rax, %r14
movq (%r15), %rax
incq %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: get_as_pointer
static int _get_as_pointer(size_t * size)
{
	size_t sz;

	sz = _variable_sizes[VT_POINTER];
	if(size != NULL)
	{
		if(sz > *size)
			return error_set_code(-ENOSPC, "%s", strerror(ENOSPC));
		*size = sz;
	}
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x9946
cmpq $0x7, (%rdi)
ja 0x993f
pushq %rax
pushq $0x1c
popq %rdi
callq 0x47f0
leaq 0x172d(%rip), %rsi      # 0xb05e
pushq $-0x1c
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rcx
jmp 0x4610
movq $0x8, (%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_is_instance
bool variable_is_instance(Variable const * variable, String const * name)
{
	if(!variable_is_type(variable, VT_COMPOUND)
			|| variable->u.compound.name == NULL)
		return false;
	return (string_compare(variable->u.compound.name, name) == 0)
		? true : false;
}

// Assembly:
cmpl $0xf, (%rdi)
jne 0x999e
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x999e
pushq %rax
callq 0x4230
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: variable_copy
VariableError variable_copy(Variable * variable, Variable const * from)
{
	Buffer * b;
	String * s;
	Array * a;

	switch(from->type)
	{
		case VT_NULL:
		case VT_BOOL:
		case VT_INT8:
		case VT_UINT8:
		case VT_INT16:
		case VT_UINT16:
		case VT_INT32:
		case VT_UINT32:
		case VT_INT64:
		case VT_UINT64:
		case VT_FLOAT:
		case VT_DOUBLE:
		case VT_POINTER:
			_variable_destroy(variable);
			memcpy(&variable->u, &from->u, sizeof(from->u));
			break;
		case VT_BUFFER:
			if((b = buffer_new_copy(from->u.buffer)) == NULL)
				return -1;
			_variable_destroy(variable);
			variable->u.buffer = b;
			break;
		case VT_STRING:
			if((s = string_new(from->u.string)) == NULL)
				return -1;
			_variable_destroy(variable);
			variable->u.string = s;
			break;
		case VT_ARRAY:
			if((a = array_new_copy(from->u.array.array)) == NULL)
				return -1;
			_variable_destroy(variable);
			variable->u.array.type = from->u.array.type;
			variable->u.array.array = a;
			break;
		case VT_COMPOUND:
			return _copy_compound(variable, from);
		default:
			/* TODO implement */
			return error_set_code(-ENOSYS, "%s", strerror(ENOSYS));
	}
	variable->type = from->type;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl (%rsi), %eax
cmpq $0x10, %rax
ja 0x9ba9
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1961(%rip), %rcx      # 0xb458
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x9256
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
callq 0x4790
jmp 0x9b62
movq 0x10(%r14), %rdi
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0x9bd1
callq 0x41f0
movq %rax, %r15
testq %rax, %rax
jne 0x9bd4
jmp 0x9b20
movq 0x8(%r14), %rdi
callq 0x41f0
testq %rax, %rax
je 0x9ba1
movq %rax, %r15
movq %rbx, %rdi
callq 0x9256
movq %r15, 0x8(%rbx)
jmp 0x9b19
movq 0x10(%r14), %rdi
callq 0x4740
testq %rax, %rax
je 0x9ba1
movq %rax, %r15
movq %rbx, %rdi
callq 0x9256
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
jmp 0x9b19
pushq $-0x1
popq %rbp
jmp 0x9b20
pushq $0x26
popq %rdi
callq 0x47f0
leaq 0x14a6(%rip), %rsi      # 0xb05e
pushq $-0x26
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4610
xorl %r15d, %r15d
callq 0x4390
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x9c21
movq %rax, %r12
movq 0x18(%r14), %rdi
leaq 0x400(%rip), %rsi       # 0x9ff1
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x43a0
cmpq $0x0, (%r14)
je 0x9c19
movq %rbx, %rdi
callq 0x9256
movq %r15, 0x10(%rbx)
movq %r12, 0x18(%rbx)
jmp 0x9b1e
movq %r12, %rdi
callq 0xa03b
movq %r15, %rdi
callq 0x4260
jmp 0x9b20
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/variable.c
// Function: new_copy_compound_foreach
static void _new_copy_compound_foreach(Mutator const * mutator,
		String const * key, void * value, void * data)
{
	Mutator ** m = (Mutator **)data;
	Variable const * from = (Variable const *)value;
	Variable * v;
	(void) mutator;

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

// Assembly:
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x9fa8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x45a0
testq %rax, %rax
je 0x9f6f
movq %rax, %r12
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x44e0
movq %r12, %rdi
callq 0x4330
movq %r15, %rdi
callq 0x40a0
movq %rax, %r15
testq %rax, %rax
je 0x9f91
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x44e0
testl %eax, %eax
je 0x9f9d
movq %r15, %rdi
callq 0x4330
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %rdi
movl (%rdx), %esi
movq (%rcx), %rax
movq 0x10(%rcx), %rdx
movq (%rax), %rax
xorl %r8d, %r8d
subq %rdx, %rax
cmovaeq %rax, %r8
leaq 0x8(%rsp), %rcx
movq %r8, (%rcx)
addq 0x8(%rbx), %rdx
callq 0x4660
testl %eax, %eax
je 0x9fe2
movl %eax, 0x18(%rbx)
movq 0x8(%rsp), %rax
addq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0xa03a
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
cmpq $0x0, (%rcx)
je 0xa035
movq %rsi, %r14
movq %rdx, %rdi
callq 0x40a0
movq %rax, %r15
testq %rax, %rax
je 0xa029
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x44e0
testl %eax, %eax
je 0xa035
movq %r15, %rdi
callq 0x4330
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26e4
movq %rax, %r12
movq %rax, (%rsp)
callq 0x26e4
movq %rax, 0x8(%rsp)
testq %r12, %r12
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x11d4
callq 0x1ccd
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1f2a
movq %rsp, %r15
movq (%r14), %r14
testq %r14, %r14
je 0x1207
movq (%r14), %rdi
movq %r15, %rsi
callq 0x1f5b
movq (%r14), %rdi
movl %ebx, %esi
callq 0x2410
addq $0x8, %r14
jmp 0x11e4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x26e4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1299
testl %eax, %eax
jne 0x1258
movq (%r14), %rax
movl 0x10(%rax), %eax
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0x5, %eax
jg 0x1247
callq 0x12d8
jmp 0x1258
cmpl $0x64, %eax
ja 0x1253
callq 0x1764
jmp 0x1258
callq 0x15e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1293
movq (%r15), %rax
movl (%rax), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2988
movq (%r15), %rcx
movl %eax, (%rcx)
addq $0x8, %r15
jmp 0x1271
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x8(%rdi), %rax
cmpl $0x0, 0x10(%rax)
jne 0x12d4
movq (%rdi), %rcx
movl 0x10(%rcx), %eax
addq $0x8, %rcx
xorl %edx, %edx
testl %eax, %eax
cmovgl %eax, %edx
negl %edx
pushq $-0x1
popq %rsi
pushq $0x1
popq %rax
leal (%rdx,%rsi), %edi
cmpl $-0x1, %edi
je 0x12d6
incl %esi
movq (%rcx), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpl (%rdi), %esi
je 0x12bc
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d54(%rip), %rdi      # 0x3044
callq 0x2350
movq %rax, (%rsp)
leaq 0x1d47(%rip), %rdi      # 0x3047
callq 0x2350
movq %rax, 0x8(%rsp)
leaq 0x1d39(%rip), %rdi      # 0x304a
callq 0x2350
movq %rax, 0x10(%rsp)
leaq 0x1d2b(%rip), %rdi      # 0x304d
callq 0x2350
movq %rax, 0x18(%rsp)
leaq 0x1d1d(%rip), %rdi      # 0x3050
callq 0x2350
movq %rax, 0x20(%rsp)
leaq 0x1d10(%rip), %rdi      # 0x3054
callq 0x2350
movq %rax, 0x28(%rsp)
leaq 0x1d03(%rip), %rdi      # 0x3058
callq 0x2350
movq %rax, 0x30(%rsp)
leaq 0x1cf6(%rip), %rdi      # 0x305c
callq 0x2350
movq %rax, 0x38(%rsp)
leaq 0x1cdc(%rip), %rdi      # 0x3053
callq 0x2350
movq %rax, 0x40(%rsp)
leaq 0x1ccf(%rip), %rdi      # 0x3057
callq 0x2350
movq %rax, 0x48(%rsp)
leaq 0x1cc2(%rip), %rdi      # 0x305b
callq 0x2350
movq %rax, 0x50(%rsp)
movq (%r14), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1480
movq (%rax), %rax
movq (%rax), %rcx
cmpl $0x4, (%rcx)
jne 0x1480
movq 0x8(%rax), %rax
movq (%rax), %rcx
cmpl $0x0, (%rcx)
jne 0x1480
movq 0x8(%rax), %rax
movq (%rax), %rcx
cmpl $0x1, (%rcx)
jne 0x1480
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x1480
leaq 0x1c4e(%rip), %r15      # 0x3044
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x116c
leaq 0x1c45(%rip), %rsi      # 0x3050
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
leaq 0x1c36(%rip), %r12      # 0x3053
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x116c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x116c
leaq 0x1c0d(%rip), %rsi      # 0x304d
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x116c
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x116c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x116c
movq %rsp, %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14c0
testl %eax, %eax
je 0x14a1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b88(%rip), %rdi      # 0x3030
pushq $0x2
popq %rsi
callq 0x2410
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1ccd
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1299
pushq $0x1
popq %rcx
testl %eax, %eax
jne 0x151b
movq (%r12), %rcx
movq 0x8(%r12), %rax
movl 0x10(%rax), %eax
addl 0x10(%rcx), %eax
cmpl $0x5, %eax
je 0x1512
cmpl $0x4, %eax
je 0x1509
cmpl $0x3, %eax
jne 0x152c
cmpl $0x2, 0x10(%r15)
jg 0x1519
jmp 0x152c
cmpl $0x4, 0x10(%r15)
jg 0x1519
jmp 0x152c
cmpl $0x6, 0x10(%r15)
jle 0x152c
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %ebx
xorl %r13d, %r13d
cmpq $0xb, %r13
je 0x1519
cmpq %r13, %rbx
je 0x15a1
leal -0x1(%r13), %eax
cmpl $0x3, %eax
je 0x1551
cmpl $0x2, %eax
jne 0x155b
movq 0x8(%r12), %rax
jmp 0x1555
movq (%r12), %rax
cmpl $0x0, 0x10(%rax)
je 0x15a1
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x116c
movl %r13d, %edi
callq 0x15ae
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0x14c0
testl %eax, %eax
jne 0x15a6
movq %r15, %rdi
xorl %esi, %esi
callq 0x2783
movslq %ebp, %rax
movq (%r14,%rax,8), %rdi
movq %r12, %rsi
callq 0x1f5b
incq %r13
jmp 0x1531
pushq $0x1
popq %rcx
jmp 0x151b
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x10(%rax), %eax
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbp
incl %esi
movl %ebp, %edx
movl %esi, %ecx
shll %cl, %edx
cmpl %eax, %edx
jl 0x1605
leaq 0x1a35(%rip), %r15      # 0x304d
leaq 0x1a31(%rip), %r12      # 0x3050
xorl %ecx, %ecx
movl %esi, (%rsp)
cmpl %ecx, %esi
je 0x1755
leal 0x1(%rcx), %eax
movl %eax, 0x4(%rsp)
cmpl %eax, %esi
setne %al
movq (%r14), %rdx
movl 0x10(%rdx), %r13d
movl %ecx, %edx
orb %al, %dl
testb $0x1, %dl
jne 0x169e
shll %cl, %ebp
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
subl $0x1, %r13d
jb 0x168f
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %r12, %rsi
testl %ebp, (%rax)
je 0x1674
leaq 0x19e0(%rip), %rsi      # 0x3054
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
jmp 0x1656
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x116c
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x1681
jmp 0x1744
testl %r13d, %r13d
jle 0x16e9
shll %cl, %ebp
subl $0x1, %r13d
jb 0x16de
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %r12, %rsi
testl %ebp, (%rax)
je 0x16c3
leaq 0x1991(%rip), %rsi      # 0x3054
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
jmp 0x16a5
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x116c
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x16d0
jmp 0x1744
movq 0x8(%r14), %rax
movl %ebp, %r13d
shll %cl, %r13d
movl 0x10(%rax), %ebp
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
subl $0x1, %ebp
jb 0x173a
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
leaq 0x1941(%rip), %rsi      # 0x3058
testl %r13d, (%rax)
je 0x171f
movq %r15, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
jmp 0x1700
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x116c
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x172c
movl 0x4(%rsp), %eax
movl %eax, %ecx
movl (%rsp), %esi
pushq $0x1
popq %rbp
jmp 0x1624
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x10(%rax), %r15d
leal (,%r15,8), %edi
callq 0x29c8
movq %r15, %rcx
movl %eax, 0x10(%rsp)
leaq 0x18bd(%rip), %rbp      # 0x3057
leaq 0x18b7(%rip), %r13      # 0x3058
testl %ecx, %ecx
jle 0x18fc
movl %ecx, %esi
subl 0x10(%rsp), %esi
movq %rcx, 0x8(%rsp)
xorl %edi, %edi
movl %esi, 0x14(%rsp)
callq 0x26ad
movq 0x8(%rsp), %rdi
movl %eax, %r12d
movl %edi, %r15d
subl %eax, %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rax
movl 0x10(%rax), %eax
cmpl %r15d, %eax
jge 0x1817
movq 0x8(%rsi), %rax
movq (%rax), %rax
movl (%rax), %eax
leaq 0x1864(%rip), %rsi      # 0x3050
cmpl %edi, %eax
jl 0x17f7
leaq 0x185d(%rip), %rsi      # 0x3054
cmpl %r12d, %eax
leaq 0x1853(%rip), %rax      # 0x3054
cmovlq %rax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x116c
movq 0x8(%rsp), %rdi
jmp 0x17cd
movl 0x10(%rsi), %r15d
addl %r15d, %eax
cmpl %edi, %eax
jle 0x1879
callq 0x190b
movl %eax, %r12d
movl %r15d, %eax
subl %r12d, %eax
cmpl %eax, %r12d
jle 0x1858
cmpl %r12d, %r15d
jle 0x1874
incl %r12d
movq %r14, %rdi
leaq 0x180c(%rip), %rsi      # 0x3053
movq %rbx, %rdx
callq 0x116c
movq (%r14), %rax
movl 0x10(%rax), %r15d
jmp 0x1835
testl %r12d, %r12d
jle 0x1874
decl %r12d
movq %r14, %rdi
leaq 0x17ea(%rip), %rsi      # 0x3054
movq %rbx, %rdx
callq 0x116c
jmp 0x1858
movq 0x8(%rsp), %rdi
movq 0x8(%r14), %rsi
movl 0x10(%rsi), %r15d
testl %r15d, %r15d
jle 0x18ea
decl %edi
movq %rdi, 0x8(%rsp)
callq 0x190b
movl %eax, %r12d
movl %r15d, %eax
subl %r12d, %eax
cmpl %eax, %r12d
jg 0x18d1
testl %r12d, %r12d
jle 0x18d6
decl %r12d
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x116c
jmp 0x18a0
incl %r12d
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x116c
movq 0x8(%r14), %rax
movl 0x10(%rax), %r15d
cmpl %r12d, %r15d
jg 0x18b8
movq %r14, %rdi
leaq 0x176d(%rip), %rsi      # 0x304d
movq %rbx, %rdx
callq 0x116c
jmp 0x1874
xorl %edi, %edi
movl 0x14(%rsp), %esi
callq 0x26ad
movl %eax, %ecx
jmp 0x17a1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
addq $0x8, %rsi
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x192d
movq (%rsi), %rdx
cmpl %edi, (%rdx)
je 0x192b
incl %ecx
addq $0x10, %rsi
jmp 0x1914
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rdx
movl %edi, %esi
movq %rsp, %rdi
callq 0x198e
movl %eax, %ebx
cmpl $0x1, %eax
jg 0x2248
callq 0x1cea
callq 0x26e4
movq %rax, %r14
movq %rax, 0x20(%rsp)
callq 0x26e4
movq %rax, 0x28(%rsp)
testq %r14, %r14
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x2276
callq 0x1ccd
movq (%rsp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x1f2a
movslq %ebx, %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x2664
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x22a6
callq 0x1ccd
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
xorl %edx, %edx
testl %ebx, %ebx
movl %ebx, %r12d
cmovlel %edx, %r12d
cmpq %rdx, %r12
je 0x22c5
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x22b5
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x2664
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x22e4
callq 0x1ccd
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0x22fa
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x22ea
movq 0x8(%rsp), %rdi
leaq (%rdi,%r15,4), %rsi
leaq 0x562(%rip), %rdx       # 0x286c
callq 0x2886
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x1264
leaq 0x20(%rsp), %rdi
callq 0x1214
movq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rax, %rdi
movl %ebx, %edx
callq 0x1193
callq 0x1cea
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
leaq -0x32(%rip), %r14       # 0x286c
cmovneq %rdx, %r14
movq %rdi, %r15
subq %rdi, %rbx
shrq $0x2, %rbx
movl %ebx, %r12d
testl %r12d, %r12d
jle 0x28c9
decl %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
movq %r14, %rcx
callq 0x2900
jmp 0x28af
leal -0x1(%rbx), %r12d
cmpl $0x2, %ebx
jl 0x28f7
movl (%r15,%r12,4), %eax
movl (%r15), %ecx
movl %ecx, (%r15,%r12,4)
movl %eax, (%r15)
movq %r15, %rdi
xorl %esi, %esi
movl %r12d, %edx
movq %r14, %rcx
callq 0x2900
decl %ebx
decq %r12
jmp 0x28cd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
leal 0x1(,%r12,2), %ebx
cmpl %r14d, %ebx
jge 0x2976
leal (%r12,%r12), %r13d
addl $0x2, %r13d
cmpl %r14d, %r13d
jge 0x294c
movl %ebx, %eax
movl (%r15,%rax,4), %edi
movl %r13d, %eax
movl (%r15,%rax,4), %esi
callq *-0x30(%rbp)
testl %eax, %eax
je 0x294c
movl %r13d, %ebx
movl %ebx, %r13d
movl (%r15,%r13,4), %edi
movl %r12d, %r12d
movl (%r15,%r12,4), %esi
callq *-0x30(%rbp)
testl %eax, %eax
jne 0x2976
movl (%r15,%r12,4), %eax
movl (%r15,%r13,4), %ecx
movl %ecx, (%r15,%r12,4)
movl %eax, (%r15,%r13,4)
movl %ebx, %r12d
jmp 0x291b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
movl %edx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movl %r8d, %r10d
leal 0x1(%r10), %r11d
cmpl %r11d, %esi
jle 0x29c1
leal (%rsi,%r10), %eax
cltd
idivl %r9d
movslq %eax, %rdx
cmpl %ecx, (%rdi,%rdx,4)
jl 0x29bc
movl %eax, %esi
jg 0x29a1
jmp 0x29c4
movl %eax, %r10d
jmp 0x299d
movl %r8d, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x2, %edi
jge 0x29d5
movl %edi, %eax
popq %rbp
retq
movslq %edi, %rcx
xorl %edi, %edi
movabsq $0x2, %rsi
movq %rcx, %r8
movq %r8, %rax
subq %rdi, %rax
cmpq $0x2, %rax
jl 0x29d1
leaq (%r8,%rdi), %rax
cqto
idivq %rsi
movq %rax, %rdx
imulq %rax, %rdx
cmpq %rcx, %rdx
cmovleq %rax, %rdi
cmovgq %rax, %r8
jmp 0x29e7
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rdi
testq %rsi, %rsi
cmoveq %rsi, %rdx
movq %rcx, %rax
subq %rdx, %rax
addq %rax, 0x29c95(%rip)     # 0x2e2b8
testq %rcx, %rcx
je 0x4630
movq %rcx, %rsi
jmp 0x43b0
pushq %rbp
movq %rsp, %rbp
callq 0x4050
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x2dcd(%rip), %rax      # 0x4000
movq %rax, 0x4e9e(%rip)      # 0x60d8
leaq 0x4e97(%rip), %rax      # 0x60d8
leaq 0x40(%rip), %rcx        # 0x1288
movq %rcx, 0x4e91(%rip)      # 0x60e0
leaq 0x96(%rip), %rcx        # 0x12ec
movq %rcx, 0x4e8b(%rip)      # 0x60e8
leaq 0x227(%rip), %rcx       # 0x148b
movq %rcx, 0x4e85(%rip)      # 0x60f0
leaq 0x36b(%rip), %rcx       # 0x15dd
movq %rcx, 0x4e7f(%rip)      # 0x60f8
leaq 0x39b(%rip), %rcx       # 0x161b
movq %rcx, 0x4e79(%rip)      # 0x6100
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x2d6d(%rip), %rsi      # 0x4005
callq 0x10f0
testq %rax, %rax
je 0x12e0
movq %rax, %rbx
leaq 0xd(%rsp), %r14
pushq $0x1
popq %rsi
pushq $0x3
popq %r15
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1060
movq %rbx, %rdi
callq 0x1070
leaq 0x2d42(%rip), %rsi      # 0x4010
movq %r14, %rdi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
sete %al
jmp 0x12e2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/src/jpeg.c
// Function: write_jpeg
static int write_jpeg(image_info_t image_info, void (*progress_update)(uint64_t, uint64_t))
{
	errno = EXIT_SUCCESS;

	FILE *fp = fopen(image_info.file, "wb");
	if (!fp)
		return errno;

	jpeg_message_t msg = { image_info.width, NULL };
	msg.data = malloc(msg.size); // total capacity

	/* retrieve the image data */
	jpeg_image_t *image = image_info.extra;

	/* copy message from image_info.buffer to message.data */
	for (uint64_t x = 0, i = 0; x < image_info.width * image_info.bpp; x += image_info.bpp, i++)
	{
		msg.data[i]  = (image_info.buffer[0][x + 0] & 0x07) << 5;
		msg.data[i] |= (image_info.buffer[0][x + 1] & 0x03) << 3;
		msg.data[i] |= (image_info.buffer[0][x + 2] & 0x07);
		if (progress_update)
			progress_update(x, image_info.width);
	}
	free(image_info.buffer[0]);
	free(image_info.buffer);

	/* get actual message length from data */
	memcpy(&msg.size, msg.data, sizeof msg.size);
	msg.size = ntohll(msg.size);

	/* write the message to the image */
	jpeg_encode_data(fp, &msg, image);

	free(msg.data);
	for (uint64_t i = 0; i < image->height; i++)
		free(image->rgb[i]);
	free(image->rgb);
	free(image);

	fclose(fp);

	return errno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
callq 0x1050
movq %rax, %rbx
andl $0x0, (%rax)
movq 0x70(%rsp), %rdi
leaq 0x2b55(%rip), %rsi      # 0x4008
callq 0x10f0
testq %rax, %rax
je 0x15cc
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x70(%rsp), %r14
movq 0x30(%r14), %rbp
movq %rbp, %rdi
callq 0x1110
movq %rax, %r13
movq %rax, 0x30(%rsp)
movq 0x40(%r14), %rbx
movq 0x48(%r14), %r15
movzwl 0x38(%r14), %ecx
movq %rbp, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
imulq %rcx, %rbp
xorl %r14d, %r14d
movq %rax, (%rsp)
movq (%rbx), %rdi
cmpq %rbp, %r14
jae 0x1557
movb (%rdi,%r14), %al
shlb $0x5, %al
movb %al, (%r13)
movq (%rbx), %rcx
movb 0x1(%rcx,%r14), %cl
shlb $0x3, %cl
andb $0x18, %cl
orb %al, %cl
movb %cl, (%r13)
movq (%rbx), %rax
movb 0x2(%rax,%r14), %al
andb $0x7, %al
orb %cl, %al
movb %al, (%r13)
testq %r12, %r12
je 0x154d
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq *%r12
addq 0x20(%rsp), %r14
incq %r13
jmp 0x1506
callq 0x1040
movq %rbx, %rdi
callq 0x1040
movq (%rsp), %rax
movq (%rax), %rax
bswapq %rax
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1130
movq 0x8(%rbx), %rdi
callq 0x1040
xorl %ebx, %ebx
movl 0xc(%r15), %eax
movq (%r15), %rdi
cmpq %rax, %rbx
jae 0x15ae
movq (%rdi,%rbx,8), %rdi
callq 0x1040
incq %rbx
jmp 0x1594
callq 0x1040
movq %r15, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1070
movq 0x10(%rsp), %rax
movl (%rax), %eax
jmp 0x15ce
movl (%rbx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq