LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_replace
int string_replace(String ** string, String const * what, String const * by)
{
	String * ret = NULL;
	String const * p;
	size_t len = string_get_length(what);
	ssize_t index;
	String * q;

	for(p = *string; (index = string_index(p, what)) >= 0; p += index + len)
	{
		if((q = string_new_length(p, index)) == NULL
				|| string_append(&ret, q) != 0
				|| string_append(&ret, by) != 0)
		{
			string_delete(q);
			string_delete(ret);
			return -1;
		}
		string_delete(q);
	}
	if(ret != NULL)
	{
		if(string_append(&ret, p) != 0)
		{
			string_delete(ret);
			return -1;
		}
		string_delete(*string);
		*string = ret;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rsp)
movq $-0x1, %r14
cmpb $0x0, 0x1(%r15,%r14)
leaq 0x1(%r14), %r14
jne 0x81bd
movq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4160
testq %rax, %rax
js 0x824a
movq %rax, %rbp
movq %rbx, 0x8(%rsp)
movq %rsp, %r13
movq %r12, %rdi
movq %rbp, %rsi
callq 0x41d0
movq %rax, %rbx
testq %rax, %rax
je 0x8273
movq %r13, %rdi
movq %rbx, %rsi
callq 0x43b0
testl %eax, %eax
jne 0x8273
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x43b0
testl %eax, %eax
jne 0x8273
movq %rbx, %rdi
callq 0x4460
movq %r12, %rbx
addq %rbp, %rbx
leaq (%rbx,%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4160
movq %rax, %rbp
testq %rax, %rax
jns 0x81e7
addq %r14, %rbx
movq %rbx, %r12
movq 0x8(%rsp), %rbx
xorl %ebp, %ebp
cmpq $0x0, (%rsp)
je 0x8289
movq %rsp, %rdi
movq %r12, %rsi
callq 0x43b0
testl %eax, %eax
jne 0x827b
movq (%rbx), %rdi
callq 0x4460
movq (%rsp), %rax
movq %rax, (%rbx)
jmp 0x8289
movq %rbx, %rdi
callq 0x4460
movq (%rsp), %rdi
callq 0x4460
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_append_formatv
int string_append_formatv(String ** string, String const * format, va_list ap)
{
	va_list v;
	int alen;
	size_t len;
	size_t s;

	if(format == NULL)
		return error_set_code(-EINVAL, "%s", strerror(EINVAL));
	va_copy(v, ap);
	alen = vsnprintf(NULL, 0, format, v);
	va_end(v);
	if(alen < 0)
		return error_set_code(-errno, "%s", strerror(errno));
	len = string_get_length(*string);
	s = (size_t)alen + 1;
	if(object_resize((Object **)string, len + s) != 0)
		return -1;
	if(vsnprintf(&(*string)[len], s, format, ap) != alen)
	{
		error_set_code(-errno, "%s", strerror(errno));
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x840a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x41b0
testl %eax, %eax
js 0x8438
movl %eax, %ebp
movq (%r15), %rax
movq $-0x1, %r12
cmpb $0x0, 0x1(%rax,%r12)
leaq 0x1(%r12), %r12
jne 0x8393
movl %ebp, %r13d
leaq (%r12,%r13), %rsi
incq %rsi
movq %r15, %rdi
callq 0x46d0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x845b
incq %r13
addq (%r15), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x41b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
je 0x845b
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x4790
leaq 0x2c67(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x845b
movl $0x16, %edi
callq 0x4790
leaq 0x2c43(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x4790
leaq 0x2c0f(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x84db
decq %rdx
je 0x84d2
leaq (%rdi,%rdx), %rax
leaq (%rsi,%rdx), %rcx
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x84d2
cmpb (%rsi), %r8b
jne 0x84d2
incq %rdi
incq %rsi
decq %rdx
jne 0x84b4
movq %rax, %rdi
movq %rcx, %rsi
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r13
movl $0x8, %edi
callq 0x45b0
testq %rax, %rax
je 0x8624
movq %rax, %rbx
testq %r14, %r14
je 0x85fc
movl $0x1, %ebp
movq %r14, %rax
decq %rbp
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x8519
testq %rbp, %rbp
je 0x85fc
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
testq %rax, %rax
js 0x85c2
movq %rax, %r15
movq %r14, 0x20(%rsp)
movq %rbp, %rax
negq %rax
movq %rax, 0x18(%rsp)
movq %r13, %rax
subq %rbp, %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movq %r13, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x41d0
movq %rax, %r13
testq %rax, %rax
je 0x85e1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
jne 0x85e1
movq %r15, %r12
addq %r14, %r12
movq 0x18(%rsp), %rax
leaq (%rax,%r12), %r14
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %r13
movq %r13, %rdi
movq 0x20(%rsp), %rsi
callq 0x4160
movq %rax, %r15
testq %rax, %rax
jns 0x8568
movq 0x8(%rsp), %r13
addq %r12, %r13
subq %rbp, %r13
movq %r13, %rdi
callq 0x41f0
movq %rax, %r13
testq %rax, %rax
je 0x85e1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
je 0x8626
movq %r13, %rdi
callq 0x4460
leaq 0x107(%rip), %rsi       # 0x86f7
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4040
jmp 0x861c
movl $0x16, %edi
callq 0x4790
leaq 0x2a51(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x4480
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %ecx, %ecx
movq %rcx, %rax
incq %rcx
cmpb $0x0, (%rdi,%rax)
jne 0x863a
xorl %edx, %edx
cmpb $0x0, (%rsi,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x8648
cmpq $0x1, %rdx
je 0x8668
leaq -0x1(%rdx), %r8
cmpq %rax, %r8
jbe 0x8669
movq $-0x1, %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq %rdx, %rcx
leaq (%rdx,%rsi), %r8
addq $-0x2, %r8
leaq -0x2(%rdx), %r9
leaq (%rdx,%rdi), %r10
addq $-0x2, %r10
xorl %eax, %eax
movq %rdi, %r11
leaq (%rdi,%rax), %rbx
cmpq $0x2, %rdx
jne 0x869c
movq %rsi, %r14
jmp 0x86d5
leaq (%r10,%rax), %r12
xorl %r15d, %r15d
movq %rsi, %r14
movb (%r11,%r15), %bpl
testb %bpl, %bpl
je 0x86d5
cmpb (%rsi,%r15), %bpl
jne 0x86cb
incq %rbx
incq %r14
incq %r15
cmpq %r15, %r9
jne 0x86a6
movq %r12, %rbx
movq %r8, %r14
jmp 0x86d5
leaq (%rsi,%r15), %r14
addq %r11, %r15
movq %r15, %rbx
movb (%rbx), %bl
cmpb (%r14), %bl
je 0x86ee
incq %rax
incq %r11
cmpq %rcx, %rax
jbe 0x868d
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x876c
movq %rsi, %r15
xorl %r14d, %r14d
movq %r15, %rax
testq %r15, %r15
je 0x874a
movb (%rax), %cl
testb %cl, %cl
je 0x8744
incq %rax
cmpb %cl, %bpl
jne 0x8736
testb %cl, %cl
jne 0x875d
jmp 0x876f
callq 0x4800
movq (%rax), %rax
movzbl %bpl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x876f
movb 0x1(%rbx,%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x872e
jmp 0x876f
xorl %r14d, %r14d
movb (%rbx,%r14), %cl
movq %r14, %rax
testb %cl, %cl
je 0x8791
leaq (%rbx,%r14), %rdx
xorl %eax, %eax
movb %cl, (%rbx,%rax)
movb 0x1(%rdx,%rax), %cl
incq %rax
testb %cl, %cl
jne 0x8780
addq %r14, %rax
subq %r14, %rax
movb $0x0, (%rbx,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %edx, %edx
movq %rdi, %rcx
movq %rdx, %rax
incq %rdx
incq %rcx
cmpb $0x0, (%rdi,%rax)
jne 0x87ab
xorl %r8d, %r8d
cmpb $0x0, (%rsi,%r8)
leaq 0x1(%r8), %r8
jne 0x87bd
cmpq $0x1, %r8
je 0x8861
leaq -0x1(%r8), %r9
cmpq %rax, %r9
ja 0x885a
subq %r8, %rdx
js 0x885a
pushq %rbp
pushq %r14
pushq %rbx
subq %r8, %rcx
leaq -0x2(%r8), %rax
leaq (%r8,%rsi), %r9
addq $-0x2, %r9
leaq (%rdi,%rdx), %r10
cmpq $0x2, %r8
jne 0x8802
movq %rsi, %r11
jmp 0x883a
leaq (%r10,%rax), %r14
xorl %ebx, %ebx
movq %rsi, %r11
movb (%rcx,%rbx), %bpl
testb %bpl, %bpl
je 0x883a
cmpb (%rsi,%rbx), %bpl
jne 0x8830
incq %r10
incq %r11
incq %rbx
cmpq %rbx, %rax
jne 0x880b
movq %r14, %r10
movq %r9, %r11
jmp 0x883a
leaq (%rsi,%rbx), %r11
addq %rcx, %rbx
movq %rbx, %r10
movb (%r10), %r10b
cmpb (%r11), %r10b
je 0x8862
leaq -0x1(%rdx), %r10
decq %rcx
testq %rdx, %rdx
movq %r10, %rdx
jg 0x87f3
movq $-0x1, %rax
jmp 0x8865
movq $-0x1, %rax
retq
movq %rdx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x1, %r12
cmpb $0x0, 0x1(%r14,%r12)
leaq 0x1(%r12), %r12
jne 0x887f
xorl %r15d, %r15d
testq %r12, %r12
je 0x88ef
testq %rbx, %rbx
je 0x88b7
movb (%rbx), %dl
testb %dl, %dl
je 0x88d7
movb -0x1(%r14,%r12), %cl
xorl %eax, %eax
cmpb %dl, %cl
je 0x88db
movb 0x1(%rbx,%rax), %dl
incq %rax
testb %dl, %dl
jne 0x88a6
jmp 0x88e4
callq 0x4800
movq (%rax), %rax
movzbl -0x1(%r14,%r12), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x88ef
movb $0x0, -0x1(%r14,%r12)
incq %r15
jmp 0x88ea
xorl %eax, %eax
jmp 0x88e4
movb $0x0, -0x1(%r14,%r12)
incq %r15
cmpb $0x0, (%rbx,%rax)
je 0x88ef
decq %r12
jne 0x8894
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x28, %edi
callq 0x45e0
testq %rax, %rax
je 0x8a3b
movq %rax, %rbx
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
testq %r15, %r15
je 0x89ea
movq %r15, %rdi
callq 0x41f0
jmp 0x89ec
xorl %eax, %eax
testq %r15, %r15
setne %cl
movq %rax, 0x10(%rbx)
movl %r14d, 0x18(%rbx)
movl %ebp, 0x1c(%rbx)
movq $0x0, 0x20(%rbx)
testq %rax, %rax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x8a3d
callq 0x40e0
movl (%rax), %edi
callq 0x4790
leaq 0x263a(%rip), %rsi      # 0xb05e
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/token.c
// Function: token_in_set
int token_in_set(Token * token, TokenSet set)
{
	TokenCode * code;

	for(code = set; *code != TC_NULL; code++)
		if(token->code == *code)
			return 1;
	return 0;
}

// Assembly:
movl (%rsi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x8b12
movl (%rdi), %edx
addq $0x4, %rsi
cmpl %ecx, %edx
je 0x8b13
movl (%rsi), %ecx
addq $0x4, %rsi
testl %ecx, %ecx
jne 0x8b04
retq
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %edi
callq 0x45e0
testq %rax, %rax
je 0x8bde
movq %rax, %rbx
movl $0x0, (%rax)
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4130
testl %eax, %eax
je 0x8be0
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rsi, %r15
movl %edi, %esi
movl $0xe, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4670
testq %rax, %rax
je 0x903b
movq %rax, %rbx
testq %r15, %r15
je 0x903d
xorl %r12d, %r12d
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x9002
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x900e
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rdx
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x44f0
testl %eax, %eax
jne 0x902b
incq %r12
cmpq %r12, %r15
jne 0x8fea
jmp 0x903d
movq %rbx, %rdi
callq 0x97a8
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xf, %edi
xorl %eax, %eax
callq 0x4670
testq %rax, %rax
je 0x91e3
movq %rax, %rbx
movq 0x18(%rax), %r15
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x9131
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x913d
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %ebp
testl %ebp, %ebp
je 0x91e5
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x915f
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x916b
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %r12
testq %r12, %r12
je 0x91d3
movq %r15, %rdi
movq %r12, %rsi
callq 0x4560
testq %rax, %rax
je 0x9196
movq %rax, %r13
movq %rax, %rdi
callq 0x97a8
movq %r13, %rdi
callq 0x4460
movl %ebp, %edi
movq %r14, %rsi
callq 0x4350
testq %rax, %rax
je 0x91d3
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x44a0
testl %eax, %eax
je 0x9119
testq %r13, %r13
je 0x91d3
movq %r13, %rdi
callq 0x97a8
movq %r13, %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x97a8
movq %rbx, %rdi
callq 0x4460
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_O1/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, %rbx
movq %rdi, %rsi
movl $0xf, %edi
xorl %eax, %eax
callq 0x4670
testq %rax, %rax
je 0x92d9
movq %rax, %r13
testq %rbx, %rbx
je 0x929b
movq %r13, (%rsp)
movq 0x18(%r13), %r13
xorl %r14d, %r14d
movq (%r12,%r14,8), %rsi
testq %rsi, %rsi
je 0x92a0
movq %r13, %rdi
callq 0x4560
testq %rax, %rax
je 0x926d
movq %rax, %rbp
movq (%r12,%r14,8), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x44a0
movq %rbp, %rdi
callq 0x97a8
movq %rbp, %rdi
callq 0x4460
movq (%r15,%r14,8), %rdi
callq 0x40a0
testq %rax, %rax
je 0x92c0
movq (%r12,%r14,8), %rsi
movq %r13, %rdi
movq %rax, %rdx
callq 0x44a0
testl %eax, %eax
jne 0x92c0
incq %r14
cmpq %r14, %rbx
jne 0x9236
movq %rbx, %r14
jmp 0x92c0
xorl %r14d, %r14d
jmp 0x92c4
movl $0x16, %edi
callq 0x4790
leaq 0x1dad(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq (%rsp), %r13
cmpq %rbx, %r14
je 0x92dc
movq %r13, %rdi
callq 0x97a8
movq %r13, %rdi
callq 0x4460
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x94eb
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
setne %cl
testq %rsi, %rsi
setne %sil
testb %cl, %sil
jne 0x9510
movl $0x16, %edi
callq 0x4790
leaq 0x1b62(%rip), %rsi      # 0xb05e
xorl %r14d, %r14d
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x9535
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_O1/DeforaOS[P]libSystem/src/variable.c
// Function: variable_destroy
static void _variable_destroy(Variable * variable)
{
	switch(variable->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:
			break;
		case VT_BUFFER:
			buffer_delete(variable->u.buffer);
			break;
		case VT_STRING:
			string_delete(variable->u.string);
			break;
		case VT_ARRAY:
			array_delete(variable->u.array.array);
			break;
		case VT_COMPOUND:
			_variable_destroy_compound(variable);
			break;
	}
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
addl $-0xc, %eax
cmpl $0x3, %eax
ja 0x980b
movq %rdi, %rbx
leaq 0x1ad3(%rip), %rcx      # 0xb290
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x4630
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x4480
movq 0x10(%rbx), %rdi
callq 0x4260
movq 0x18(%rbx), %rbx
leaq 0x114e(%rip), %rsi      # 0xa93c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4380
movq %rbx, %rdi
popq %rbx
jmp 0x4760
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x4260
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa239
cmpq $0x7, (%rdi)
ja 0xa232
pushq %rax
movl $0x1c, %edi
callq 0x4790
leaq 0xe3c(%rip), %rsi       # 0xb05e
movl $0xffffffe4, %edi       # imm = 0xFFFFFFE4
movq %rax, %rdx
xorl %eax, %eax
popq %rcx
jmp 0x45d0
movq $0x8, (%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa291
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa291
pushq %rax
callq 0x4230
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xc, %eax
jae 0xa408
movq %rbx, %rdi
callq 0x97a8
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addl $-0xc, %eax
cmpl $0x4, %eax
ja 0xa4a2
leaq 0x116d(%rip), %rcx      # 0xb588
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
callq 0x4730
jmp 0xa45b
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xa4cd
callq 0x41f0
movq %rax, %r15
testq %rax, %rax
jne 0xa4d0
jmp 0xa533
movq 0x8(%r14), %rdi
callq 0x41f0
testq %rax, %rax
je 0xa533
movq %rax, %r15
movq %rbx, %rdi
callq 0x97a8
movq %r15, 0x8(%rbx)
jmp 0xa3f5
movq 0x10(%r14), %rdi
callq 0x46e0
testq %rax, %rax
je 0xa533
movq %rax, %r15
movq %rbx, %rdi
callq 0x97a8
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
jmp 0xa3f5
movl $0x26, %edi
callq 0x4790
leaq 0xbab(%rip), %rsi       # 0xb05e
movl $0xffffffda, %edi       # imm = 0xFFFFFFDA
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x45d0
xorl %r15d, %r15d
callq 0x4370
movq %rax, (%rsp)
testq %rax, %rax
je 0xa52b
movq %rax, %r12
movq 0x18(%r14), %rdi
leaq 0x3f6(%rip), %rsi       # 0xa8e2
movq %rsp, %r14
movq %r14, %rdx
callq 0x4380
cmpq $0x0, (%r14)
je 0xa512
movq %rbx, %rdi
callq 0x97a8
movq %r15, 0x10(%rbx)
movq %r12, 0x18(%rbx)
jmp 0xa3fa
leaq 0x423(%rip), %rsi       # 0xa93c
movq %r12, %rdi
xorl %edx, %edx
callq 0x4380
movq %r12, %rdi
callq 0x4760
movq %r15, %rdi
callq 0x4260
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa3fc
// File: /workspace/github_c_makefile_star2_O1/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 0xa896
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4560
testq %rax, %rax
je 0xa84d
movq %rax, %r12
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x44a0
movq %r12, %rdi
callq 0x97a8
movq %r12, %rdi
callq 0x4460
movq %r15, %rdi
callq 0x40a0
testq %rax, %rax
je 0xa884
movq %rax, %r15
movq (%rbx), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x44a0
testl %eax, %eax
je 0xa88b
testq %r15, %r15
je 0xa884
movq %r15, %rdi
callq 0x97a8
movq %r15, %rdi
callq 0x4460
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rax), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rdx
xorl %r8d, %r8d
subq %rdx, %rax
cmovaeq %rax, %r8
movq %r8, (%rcx)
addq 0x8(%rbx), %rdx
callq 0x4620
testl %eax, %eax
je 0xa8d3
movl %eax, 0x18(%rbx)
movq 0x8(%rsp), %rax
addq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa93b
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
cmpq $0x0, (%rcx)
je 0xa936
movq %rsi, %r15
movq %rdx, %rdi
callq 0x40a0
testq %rax, %rax
je 0xa92f
movq %rax, %r14
movq (%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x44a0
testl %eax, %eax
je 0xa936
testq %r14, %r14
je 0xa92f
movq %r14, %rdi
callq 0x97a8
movq %r14, %rdi
callq 0x4460
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x2840
movq %rax, (%rsp)
callq 0x2840
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rsp)
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x11e1
callq 0x1db5
movq (%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2016
movq (%r14), %r15
testq %r15, %r15
je 0x1218
movq %rsp, %r14
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2042
movq (%r15), %rdi
movl %ebx, %esi
callq 0x2548
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x11fa
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2840
movq %rax, %rbx
movq %r14, %rdi
callq 0x12a9
testl %eax, %eax
jne 0x1267
movq (%r14), %rax
movl 0x10(%rax), %eax
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0x5, %eax
jg 0x1256
callq 0x12e4
jmp 0x1267
cmpl $0x64, %eax
jg 0x1262
callq 0x17ec
jmp 0x1267
callq 0x1640
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq (%rdi), %r15
testq %r15, %r15
je 0x12a3
movl %edx, %ebx
movq %rsi, %r14
movq (%r15), %rax
movl (%rax), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2b0c
movq (%r15), %rcx
movl %eax, (%rcx)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x1286
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
xorl %eax, %eax
cmpl $0x0, 0x10(%rcx)
je 0x12b6
retq
movq (%rdi), %rcx
movl 0x10(%rcx), %edx
movl $0x1, %eax
testl %edx, %edx
jle 0x12b5
addq $0x8, %rcx
xorl %esi, %esi
movq (%rcx), %rcx
movq (%rcx), %rdi
cmpl (%rdi), %esi
jne 0x12e1
addq $0x10, %rcx
incl %esi
cmpl %esi, %edx
jne 0x12cb
jmp 0x12b5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d48(%rip), %rdi      # 0x3044
callq 0x2488
movq %rax, (%rsp)
leaq 0x1d3b(%rip), %rdi      # 0x3047
callq 0x2488
movq %rax, 0x8(%rsp)
leaq 0x1d2d(%rip), %rdi      # 0x304a
callq 0x2488
movq %rax, 0x10(%rsp)
leaq 0x1d1f(%rip), %rdi      # 0x304d
callq 0x2488
movq %rax, 0x18(%rsp)
leaq 0x1d11(%rip), %rdi      # 0x3050
callq 0x2488
movq %rax, 0x20(%rsp)
leaq 0x1d04(%rip), %rdi      # 0x3054
callq 0x2488
movq %rax, 0x28(%rsp)
leaq 0x1cf7(%rip), %rdi      # 0x3058
callq 0x2488
movq %rax, 0x30(%rsp)
leaq 0x1cea(%rip), %rdi      # 0x305c
callq 0x2488
movq %rax, 0x38(%rsp)
leaq 0x1cd0(%rip), %rdi      # 0x3053
callq 0x2488
movq %rax, 0x40(%rsp)
leaq 0x1cc3(%rip), %rdi      # 0x3057
callq 0x2488
movq %rax, 0x48(%rsp)
leaq 0x1cb6(%rip), %rdi      # 0x305b
callq 0x2488
movq %rax, 0x50(%rsp)
movq (%r14), %rax
cmpl $0x5, 0x10(%rax)
jne 0x148c
movq (%rax), %rax
movq (%rax), %rcx
cmpl $0x4, (%rcx)
jne 0x148c
movq 0x8(%rax), %rax
movq (%rax), %rcx
cmpl $0x0, (%rcx)
jne 0x148c
movq 0x8(%rax), %rax
movq (%rax), %rcx
cmpl $0x1, (%rcx)
jne 0x148c
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x148c
leaq 0x1c42(%rip), %r15      # 0x3044
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x117c
leaq 0x1c39(%rip), %rsi      # 0x3050
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
leaq 0x1c2a(%rip), %r12      # 0x3053
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x117c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x117c
leaq 0x1c01(%rip), %rsi      # 0x304d
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x117c
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x117c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x117c
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x14d0
testl %eax, %eax
je 0x14af
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b7a(%rip), %rdi      # 0x3030
movl $0x2, %esi
callq 0x2548
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1db5
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x12a9
movl $0x1, %ecx
testl %eax, %eax
jne 0x1627
movq (%r12), %rcx
movq 0x8(%r12), %rax
movl 0x10(%rax), %eax
addl 0x10(%rcx), %eax
cmpl $0x5, %eax
je 0x153e
cmpl $0x4, %eax
je 0x152e
cmpl $0x3, %eax
jne 0x1549
cmpl $0x2, 0x10(%r15)
jg 0x1625
cmpl $0x5, %eax
je 0x153e
cmpl $0x4, %eax
jne 0x1549
cmpl $0x4, 0x10(%r15)
jg 0x1625
cmpl $0x5, %eax
jne 0x1549
cmpl $0x6, 0x10(%r15)
jg 0x1625
movl %ebp, %r13d
xorl %ebp, %ebp
movabsq $0x600000005, %rbx      # imm = 0x600000005
cmpq %rbp, %r13
je 0x1618
leaq -0x1(%rbp), %rax
cmpl $0x3, %eax
je 0x1584
cmpl $0x2, %eax
jne 0x1592
movq 0x8(%r12), %rax
cmpl $0x0, 0x10(%rax)
je 0x1618
cmpq $0x4, %rbp
jne 0x1592
movq (%r12), %rax
cmpl $0x0, 0x10(%rax)
je 0x1618
movq (%r14,%rbp,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x117c
movaps 0x1a68(%rip), %xmm0     # 0x3010
movaps %xmm0, (%rsp)
movaps 0x1a6d(%rip), %xmm0     # 0x3020
movaps %xmm0, 0x10(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x7, 0x28(%rsp)
movl (%rsp,%rbp,4), %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14d0
testl %eax, %eax
jne 0x1638
movq %r15, %rdi
xorl %esi, %esi
callq 0x28e6
movaps 0x1a25(%rip), %xmm0     # 0x3010
movaps %xmm0, (%rsp)
movaps 0x1a2a(%rip), %xmm0     # 0x3020
movaps %xmm0, 0x10(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x7, 0x28(%rsp)
movslq (%rsp,%rbp,4), %rax
movq (%r14,%rax,8), %rdi
movq %r12, %rsi
callq 0x2042
incq %rbp
cmpq $0xb, %rbp
jne 0x1558
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ecx
jmp 0x1627
nop
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x10(%rax), %eax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incl %r15d
movl $0x1, %edx
movl %r15d, %ecx
shll %cl, %edx
cmpl %eax, %edx
jl 0x1660
testl %r15d, %r15d
je 0x17dd
leal 0x1(%r15), %eax
movl %eax, 0xc(%rsp)
xorl %ecx, %ecx
movl $0x1, %eax
leaq 0x19c0(%rip), %r12      # 0x3050
movq %rax, 0x10(%rsp)
cmpl %eax, %r15d
setne %al
movq (%r14), %rdx
movl 0x10(%rdx), %ebp
movl %ecx, %edx
orb %al, %dl
testb $0x1, %dl
jne 0x1711
testl %ebp, %ebp
jle 0x16df
movl $0x1, %r13d
shll %cl, %r13d
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %r12, %rsi
testl %r13d, (%rax)
je 0x16d0
leaq 0x1984(%rip), %rsi      # 0x3054
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
decl %ebp
jne 0x16b7
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
leaq 0x195f(%rip), %r13      # 0x304d
jle 0x17cb
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x117c
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x16f4
jmp 0x17cb
testl %ebp, %ebp
jle 0x1761
movl $0x1, %r13d
shll %cl, %r13d
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %r12, %rsi
testl %r13d, (%rax)
je 0x1737
leaq 0x191d(%rip), %rsi      # 0x3054
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
decl %ebp
jne 0x171e
jmp 0x1756
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x117c
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x1748
jmp 0x17cb
movq 0x8(%r14), %rax
movl 0x10(%rax), %ebp
testl %ebp, %ebp
jle 0x17a2
movl $0x1, %r13d
shll %cl, %r13d
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
leaq 0x18d1(%rip), %rsi      # 0x3058
testl %r13d, (%rax)
je 0x1793
leaq 0x18ba(%rip), %rsi      # 0x304d
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
decl %ebp
jne 0x1775
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
leaq 0x189c(%rip), %r13      # 0x304d
jle 0x17cb
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x117c
movq 0x8(%r14), %rax
cmpl $0x0, 0x10(%rax)
jg 0x17b3
movq 0x10(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl %eax, 0xc(%rsp)
jne 0x1690
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x10(%rax), %r15d
leal (,%r15,8), %edi
callq 0x2b50
movl %eax, (%rsp)
testl %r15d, %r15d
jle 0x19ca
leaq 0x1834(%rip), %r13      # 0x3058
movl %r15d, %esi
subl (%rsp), %esi
xorl %edi, %edi
movl %esi, 0x4(%rsp)
callq 0x2815
movl %eax, %r12d
movl %r15d, %ebp
subl %eax, %ebp
movq 0x8(%r14), %rax
movl 0x10(%rax), %ecx
cmpl %ebp, %ecx
jge 0x1882
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
leaq 0x17f5(%rip), %rsi      # 0x3050
cmpl %r15d, %eax
jl 0x1867
leaq 0x17ed(%rip), %rsi      # 0x3054
cmpl %r12d, %eax
leaq 0x17e3(%rip), %rax      # 0x3054
cmovlq %rax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x117c
jmp 0x183d
movq (%r14), %rdx
movl 0x10(%rdx), %eax
addl %eax, %ecx
cmpl %r15d, %ecx
leaq 0x17bf(%rip), %rbp      # 0x3053
jle 0x190d
movq 0x8(%rdx), %rcx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x18bf
xorl %edx, %edx
movq (%rcx), %rsi
cmpl %r15d, (%rsi)
je 0x18bc
incl %edx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x18a7
jmp 0x18bf
movl %edx, %r12d
movl %eax, %ecx
subl %r12d, %ecx
cmpl %ecx, %r12d
jle 0x18ea
cmpl %r12d, %eax
jle 0x190d
incl %r12d
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x117c
movq (%r14), %rax
cmpl %r12d, 0x10(%rax)
jg 0x18ce
jmp 0x190d
testl %r12d, %r12d
jle 0x190d
incl %r12d
movq %r14, %rdi
leaq 0x1758(%rip), %rsi      # 0x3054
movq %rbx, %rdx
callq 0x117c
decl %r12d
cmpl $0x1, %r12d
jg 0x18f2
movq 0x8(%r14), %rcx
movl 0x10(%rcx), %eax
testl %eax, %eax
leaq 0x173a(%rip), %rbp      # 0x3057
jle 0x19b4
decl %r15d
movq 0x8(%rcx), %rcx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x194f
xorl %edx, %edx
movq (%rcx), %rsi
cmpl %r15d, (%rsi)
je 0x194c
incl %edx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x1937
jmp 0x194f
movl %edx, %r12d
subl %r12d, %eax
cmpl %eax, %r12d
jle 0x1974
movq 0x8(%r14), %rax
cmpl %r12d, 0x10(%rax)
jle 0x1993
incl %r12d
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x117c
jmp 0x1957
testl %r12d, %r12d
jle 0x1993
incl %r12d
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x117c
decl %r12d
cmpl $0x1, %r12d
jg 0x197c
movq %r14, %rdi
leaq 0x16b0(%rip), %rsi      # 0x304d
movq %rbx, %rdx
callq 0x117c
movq 0x8(%r14), %rcx
movl 0x10(%rcx), %eax
testl %eax, %eax
jg 0x1923
xorl %edi, %edi
movl 0x4(%rsp), %esi
callq 0x2815
movl %eax, %r15d
testl %eax, %eax
jg 0x1824
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movl %edi, %esi
movq %rsp, %rdi
callq 0x1a1f
movl %eax, %ebx
cmpl $0x1, %eax
jg 0x237a
callq 0x1dd6
callq 0x2840
movq %rax, 0x20(%rsp)
callq 0x2840
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x20(%rsp)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x23a8
callq 0x1db5
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl %ebx, %edx
callq 0x2016
movslq %ebx, %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x27cc
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x23d7
callq 0x1db5
movl %ebx, %r15d
testl %ebx, %ebx
jle 0x23f7
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x23e9
movl $0x4, %esi
movq %r14, %rdi
callq 0x27cc
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x2413
callq 0x1db5
testl %ebx, %ebx
jle 0x2430
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x2422
movq 0x8(%rsp), %rdi
leaq (%rdi,%r14,4), %rsi
leaq 0x5a0(%rip), %rdx       # 0x29e0
callq 0x29fa
leaq 0x20(%rsp), %r14
movq (%r14), %rdi
movq 0x8(%rsp), %rsi
movl %ebx, %edx
callq 0x1274
movq %r14, %rdi
callq 0x1223
movq 0x10(%rsp), %rsi
movq %rax, %rdi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x11a3
callq 0x1dd6
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop