LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayRemoveAt
void eaDSDynamicArrayRemoveAt(eaDSDynamicArray * dynamicArray, size_t index)
{
	size_t cnt = dynamicArray->Count;

	if (cnt && (index < cnt))
	{
		size_t j = index;

		dynamicArray->dataClear(dynamicArray->Data[index]);

		for (; j < cnt - 1; j++)
		{
			dynamicArray->Data[j] = dynamicArray->Data[j + 1];
		}

		dynamicArray->Count--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x254c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x254c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x253c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x24fe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayRemoveAtCopyLastItem
void eaDSDynamicArrayRemoveAtCopyLastItem(eaDSDynamicArray * dynamicArray, size_t index)
{
	size_t cnt = dynamicArray->Count;

	if (cnt && (index < cnt))
	{
		if ((DEFAULT_STARTING_CAPACITY < dynamicArray->Capacity) && (dynamicArray->Count < dynamicArray->Capacity / dynamicArray->ExpFactor))
		{
			void ** tmp;

			dynamicArray->Capacity /= dynamicArray->ExpFactor;
			tmp = (void **) realloc(dynamicArray->Data, dynamicArray->Capacity * sizeof(void *));

			if (NULL != tmp)
			{
				dynamicArray->Data = tmp;
			}
			else
			{
				dynamicArray->Capacity *= dynamicArray->ExpFactor;
			}
		}
		
		dynamicArray->dataClear(dynamicArray->Data[index]);

		if (cnt - 1)
		{
			dynamicArray->Data[index] = dynamicArray->Data[cnt - 1];
		}

		dynamicArray->Count--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x269e
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x269e
movq -0x8(%rbp), %rcx
movl $0x4, %eax
cmpq 0x10(%rcx), %rax
jae 0x2645
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2645
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x262c
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2643
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2645
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x18(%rbp), %rax
subq $0x1, %rax
cmpq $0x0, %rax
je 0x268e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListInit
eaDSLinkedList eaDSLinkedListInit(void * (*dataCreateAndCopy)(const void *), int (*dataCompare)(const void *, const void *), void (*dataClear)(void *))
{
	eaDSLinkedList linkedList = (eaDSLinkedList) malloc(sizeof(struct _eaDSLinkedList));

	if (NULL == linkedList)
	{
		perror(NULL);
	}
	else
	{
		linkedList->Head = NULL;
		linkedList->Tail = NULL;
		linkedList->dataCreateAndCopy = (NULL == dataCreateAndCopy) ? copyAddress : dataCreateAndCopy;
		linkedList->dataCompare = (NULL == dataCompare) ? compareAddress : dataCompare;
		linkedList->dataClear = (NULL == dataClear) ? free : dataClear;
	}

	return linkedList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x2778
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x280a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x27a4
leaq 0x82(%rip), %rax        # 0x2820
movq %rax, -0x28(%rbp)
jmp 0x27ac
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x27cd
leaq 0x69(%rip), %rax        # 0x2830
movq %rax, -0x30(%rbp)
jmp 0x27d5
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x27f6
movq 0x47e0(%rip), %rax      # 0x6fd0
movq %rax, -0x38(%rbp)
jmp 0x27fe
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListReset
void eaDSLinkedListReset(eaDSLinkedList linkedList)
{
	while(NULL != linkedList->Head)
	{
		ItemLL * tmp = linkedList->Head;
		linkedList->Head = tmp->Next;
		linkedList->dataClear(tmp->Data);

		free(tmp);
	}

	linkedList->Tail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x289d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x10e0
jmp 0x285c
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListAdd
int eaDSLinkedListAdd(eaDSLinkedList linkedList, const void * data)
{
	ItemLL * iter = linkedList->Head, * tmp;

	if(NULL == (tmp = (ItemLL *) malloc(sizeof(ItemLL))))
	{
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (NULL == (tmp->Data = linkedList->dataCreateAndCopy(data)))
	{
		free(tmp);
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (NULL == iter)
	{
		linkedList->Head = tmp;
	}
	else
	{
		linkedList->Tail->Next = tmp;
	}

	tmp->Next = NULL;
	linkedList->Tail = tmp;

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x1090
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2975
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x29f3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x29af
movq -0x28(%rbp), %rdi
callq 0x10e0
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x29f3
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x29c4
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x29d4
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListRemoveAt
void eaDSLinkedListRemoveAt(eaDSLinkedList linkedList, size_t index)
{
	void * p;
	size_t i;
	ItemLL * iter = linkedList->Head;

	if (NULL == iter)
	{
		return;
	}

	for (i = 0; i < index; i++)
	{
		if ((iter->Next == linkedList->Tail) && ((i + 1) == index))
		{
			linkedList->dataClear(iter->Next->Data);
			free(iter->Next);
			iter->Next = NULL;
			linkedList->Tail = iter;

			return;
		}

		if (NULL == iter->Next)
		{
			if (0 == index)
			{
				linkedList->dataClear(iter->Data);
				free(iter);
				linkedList->Head = NULL;
				linkedList->Tail = NULL;
			}

			return;
		}

		iter = iter->Next;
	}

	linkedList->dataClear(iter->Data);

	p = iter->Next->Next;
	iter->Data = iter->Next->Data;

	free(iter->Next);
	iter->Next = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x2bc8
jmp 0x2ced
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2ca1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2c3d
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
jne 0x2c3d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2ced
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x2c84
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x2c82
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x28(%rbp), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2ced
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2bd0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListInsert
int eaDSLinkedListInsert(eaDSLinkedList linkedList, const void * data, size_t index)
{
	size_t i;
	void * p;
	ItemLL * iter = linkedList->Head, * tmp = (ItemLL *) malloc(sizeof(ItemLL));

	if(NULL == tmp)
	{
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (NULL == (p = linkedList->dataCreateAndCopy(data)))
	{
		free(tmp);
		perror(NULL);

		return EXIT_FAILURE;
	}

	for (i = 0; i < index; i++)
	{
		if (NULL == iter)
		{
			return EXIT_FAILURE;
		}
		iter = iter->Next;
	}

	if (0 == index || NULL == iter)
	{
		tmp->Next = iter;
		iter = tmp;

		if (0 == index)
		{
			linkedList->Head = tmp;
		}
	}
	else
	{
		tmp->Data = iter->Data;
		tmp->Next = iter->Next;
		iter->Next = tmp;
	}

	iter->Data = p;

	if (NULL == iter->Next)
	{
		linkedList->Tail = iter;
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x1090
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x40(%rbp), %rax
jne 0x2d4a
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x2e51
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2d84
movq -0x40(%rbp), %rdi
callq 0x10e0
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x2e51
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2dc4
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jne 0x2daa
movl $0x1, -0x4(%rbp)
jmp 0x2e51
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2d8c
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x2dd4
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jne 0x2dfd
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x2dfb
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2e27
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x2e4a
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListGetFrom
void * eaDSLinkedListGetFrom(const eaDSLinkedList linkedList, size_t index)
{
	size_t i = 0;
	void * data = NULL;
	ItemLL * iter = linkedList->Head;

	while (NULL != iter)
	{
		if (index == i++)
		{
			if (NULL == (data = linkedList->dataCreateAndCopy(iter->Data)))
			{
				perror(NULL);
			}

			break;
		}

		iter = iter->Next;
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x2ee3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
cmpq %rcx, %rax
jne 0x2ed5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2ed3
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x2ee3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2e8b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSLinkedList.c
// Function: eaDSLinkedListGetAddressFrom
void * eaDSLinkedListGetAddressFrom(const eaDSLinkedList linkedList, size_t index)
{
	size_t i = 0;
	ItemLL * iter = linkedList->Head;

	while (NULL != iter)
	{
		if (index == i++)
		{
			return iter->Data;
		}

		iter = iter->Next;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x2f4a
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
cmpq %rcx, %rax
jne 0x2f3c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f52
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2f0f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSQueue.c
// Function: eaDSQueueInit
eaDSQueue eaDSQueueInit(void * (*dataCreateAndCopy)(const void *), void (*dataClear)(void *))
{
	eaDSQueue queue = (eaDSQueue) malloc(sizeof(struct _eaDSQueue));

	if (NULL == queue)
	{
		perror(NULL);
	}
	else
	{
		queue->Front = NULL;
		queue->Rear = NULL;
		queue->dataCreateAndCopy = (NULL == dataCreateAndCopy) ? copyAddress : dataCreateAndCopy;
		queue->dataClear = (NULL == dataClear) ? free : dataClear;
	}

	return queue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1090
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x2f91
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x2ffa
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x2fbd
leaq 0x59(%rip), %rax        # 0x3010
movq %rax, -0x20(%rbp)
jmp 0x2fc5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x2fe6
movq 0x3ff0(%rip), %rax      # 0x6fd0
movq %rax, -0x28(%rbp)
jmp 0x2fee
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSQueue.c
// Function: eaDSQueueReset
void eaDSQueueReset(eaDSQueue queue)
{
	while (NULL != queue->Front)
	{
		ItemQue * tmp = queue->Front;
		queue->Front = tmp->Next;
		queue->dataClear(tmp->Data);

		free(tmp);
	}

	queue->Rear = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x306d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x10e0
jmp 0x302c
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSQueue.c
// Function: eaDSQueueDequeue
void * eaDSQueueDequeue(eaDSQueue queue)
{
	void * p, * data;

	if (NULL == queue->Front)
	{
		return NULL;
	}

	data = queue->dataCreateAndCopy(queue->Front->Data);

	if (NULL == data)
	{
		perror(NULL);
	}

	queue->dataClear(queue->Front->Data);

	p = queue->Front;
	queue->Front = queue->Front->Next;
	free(p);

	if (NULL == queue->Front)
	{
		queue->Rear = NULL;
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x30f4
movq $0x0, -0x8(%rbp)
jmp 0x3176
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x311d
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x10e0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x316e
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSQueue.c
// Function: eaDSQueueEnqueue
int eaDSQueueEnqueue(eaDSQueue queue, const void * data)
{
	ItemQue * tmp = (ItemQue *) malloc(sizeof(ItemQue));

	if (NULL == tmp)
	{
		perror(NULL);
		return EXIT_FAILURE;
	}

	tmp->Next = NULL;
	tmp->Data = queue->dataCreateAndCopy(data);

	if (NULL == tmp->Data)
	{
		free(tmp);
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (NULL == queue->Front)
	{
		queue->Front = tmp;
	}
	else
	{
		queue->Rear->Next = tmp;
	}

	queue->Rear = tmp;
	
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x31bb
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x3240
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x3205
movq -0x20(%rbp), %rdi
callq 0x10e0
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x3240
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x321d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x322d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSQueue.c
// Function: eaDSQueuePeekValue
void * eaDSQueuePeekValue(const eaDSQueue queue)
{
	void * data = NULL;

	if (NULL == queue->Front)
	{
		return NULL;
	}

	data = queue->dataCreateAndCopy(queue->Front->Data);

	if (NULL == data)
	{
		perror(NULL);
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x3279
movq $0x0, -0x8(%rbp)
jmp 0x32aa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x32a2
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackInitWithDetails
eaDSStack eaDSStackInitWithDetails(void * (*dataCreateAndCopy)(const void *), void (*dataClear)(void *), unsigned short expFactor, unsigned short startingCapacity)
{
	eaDSStack stack = (eaDSStack) malloc(sizeof(struct _eaDSStack));

	if (NULL == stack)
	{
		perror(NULL);
	}
	else
	{
		stack->StartingCapacity = startingCapacity ? startingCapacity : DEFAULT_STARTING_CAPACITY;
		stack->Data = (void **)malloc(stack->StartingCapacity * sizeof(void *));

		if (NULL == stack->Data)
		{
			perror(NULL);
			free(stack);
			stack = NULL;
		}
		else
		{
			stack->Count = 0;
			stack->Capacity = stack->StartingCapacity;
			stack->ExpFactor = (expFactor < 2) ? DEFAULT_EXP_FACTOR : expFactor;
			stack->dataCreateAndCopy = (NULL == dataCreateAndCopy) ? copyAddress : dataCreateAndCopy;
			stack->dataClear = (NULL == dataClear) ? free : dataClear;
		}
	}

	return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movl $0x38, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x3372
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x347d
movzwl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x3384
movzwl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x338e
movl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x338e
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x1a(%rax)
movq -0x20(%rbp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x33e3
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x10e0
movq $0x0, -0x20(%rbp)
jmp 0x347b
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movzwl -0x12(%rbp), %eax
cmpl $0x2, %eax
jge 0x3414
movl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x341b
movzwl -0x12(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x18(%rax)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x343e
leaq 0x58(%rip), %rax        # 0x3490
movq %rax, -0x30(%rbp)
jmp 0x3446
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x3467
movq 0x3b6f(%rip), %rax      # 0x6fd0
movq %rax, -0x38(%rbp)
jmp 0x346f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x347d
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackReset
int eaDSStackReset(eaDSStack stack)
{
	if (NULL == stack->Data)
	{
		stack->Data = (void **) malloc(stack->Capacity * sizeof(void *));

		if (NULL == stack->Data)
		{
			perror(NULL);

			return EXIT_FAILURE;
		}
	}
	else
	{
		while (stack->Count)
		{
			stack->dataClear(stack->Data[--stack->Count]);
		}

		if (stack->StartingCapacity < stack->Capacity)
		{
			free(stack->Data);
			stack->Data = (void **) malloc(stack->Capacity * sizeof(void *));

			if (NULL == stack->Data)
			{
				perror(NULL);

				return EXIT_FAILURE;
			}

			stack->Capacity = stack->StartingCapacity;
		}
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x34f7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x34f2
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x35a0
jmp 0x3599
jmp 0x34f9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x352f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $-0x1, %rdi
movq %rdi, 0x8(%rsi)
movq -0x8(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x34f9
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3597
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x3585
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x35a0
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x3599
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackClear
void eaDSStackClear(eaDSStack stack)
{
	if (NULL != stack->Data)
	{
		while(stack->Count)
		{
			stack->dataClear(stack->Data[--stack->Count]);
		}

		free(stack->Data);
	}

	free(stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x360b
jmp 0x35c9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x35ff
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $-0x1, %rdi
movq %rdi, 0x8(%rsi)
movq -0x8(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x35c9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackPop
void * eaDSStackPop(eaDSStack stack)
{
	void * data = NULL;

	if (stack->Count)
	{
		if ((DEFAULT_STARTING_CAPACITY < stack->Capacity) && (stack->Count < stack->Capacity / stack->ExpFactor))
		{
			void ** tmp;

			stack->Capacity /= stack->ExpFactor;
			tmp = (void **) realloc(stack->Data, stack->Capacity * sizeof(void *));

			if (NULL != tmp)
			{
				stack->Data = tmp;
			}
			else 
			{
				stack->Capacity *= stack->ExpFactor;
			}
		}

		data = stack->dataCreateAndCopy(stack->Data[stack->Count - 1]);

		if (NULL != data)
		{
			stack->dataClear(stack->Data[--stack->Count]);
		}
		else
		{
			perror(NULL);
		}
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3796
movq -0x8(%rbp), %rcx
movl $0x4, %eax
cmpq 0x10(%rcx), %rax
jae 0x3733
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3733
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x371a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3731
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x3733
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x378b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $-0x1, %rdi
movq %rdi, 0x8(%rsi)
movq -0x8(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x3794
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x3796
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackPush
int eaDSStackPush(eaDSStack stack, const void * data)
{
	void * item = stack->dataCreateAndCopy(data);

	if (NULL == item)
	{
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (stack->Count == stack->Capacity)
	{
		void ** tmp;

		stack->Capacity *= stack->ExpFactor;
		tmp = (void **) realloc(stack->Data, stack->Capacity * sizeof(void *));

		if (NULL == tmp)
		{
			perror(NULL);
			stack->Capacity /= stack->ExpFactor;

			return EXIT_FAILURE;
		}

		stack->Data = tmp;
	}

	stack->Data[stack->Count] = item;
	stack->Count++;

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x37df
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x389d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x386f
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x3864
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x389d
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSStack.c
// Function: eaDSStackPeekStack
void * eaDSStackPeekStack(const eaDSStack stack)
{
	void * data = NULL;

	if (stack->Count)
	{
		data = stack->dataCreateAndCopy(stack->Data[stack->Count - 1]);

		if (NULL == data)
		{
			perror(NULL);
		}
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3907
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x3905
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x3907
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/Simulation/main.c
// Function: freeMemory
void freeMemory(eaDSDynamicArray * dynamicArray1, eaDSDynamicArray * dynamicArray2)
{
	int i;

	eaDSDynamicArrayClear(dynamicArray1);

	for (i = 0; i < COUNT_LOCATIONS; i++)
	{
		eaDSDynamicArrayClear(&dynamicArray2[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d40
movl $0x0, -0x14(%rbp)
cmpl $0x24, -0x14(%rbp)
jge 0x3ff5
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x1d40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3fd0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/RD.c
// Function: remove_dir
int remove_dir(const char *dir){
    DIR* dirp;
    struct dirent *dp;
    struct stat dir_stat;
    char dir_name[255];

    if(access(dir,F_OK)!=0){
        return 0;
    } 
    if(stat(dir, &dir_stat)<0){
        perror("dir stat errpr!\n");
        return -1;
    }
    if(S_ISREG(dir_stat.st_mode)){
        remove(dir);
    }
    else if(S_ISDIR(dir_stat.st_mode)){
        dirp=opendir(dir);
        while((dp=readdir(dirp))!=NULL){
            if((0==strcmp(".", dp->d_name))||(0==strcmp("..",dp->d_name))) 
                continue;
            
            sprintf(dir_name, "%s/%s", dir, dp->d_name);
            remove_dir(dir_name);
        }
        closedir(dirp);
        rmdir(dir);
    }
    else{
        perror("error!\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x10c0
cmpl $0x0, %eax
je 0x13cb
movl $0x0, -0x4(%rbp)
jmp 0x14e0
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1090
cmpl $0x0, %eax
jge 0x13f8
leaq 0xc1d(%rip), %rdi       # 0x2004
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14e0
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x1418
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x14d9
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x14cb
movq -0x10(%rbp), %rdi
callq 0x1040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x14b7
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
leaq 0xbb9(%rip), %rdi       # 0x2016
callq 0x1080
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1486
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
leaq 0xb9c(%rip), %rdi       # 0x2015
callq 0x1080
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1488
jmp 0x143b
leaq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x13, %rcx
leaq 0xb76(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x10e0
leaq -0x1b0(%rbp), %rdi
callq 0x13a0
jmp 0x143b
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x1050
jmp 0x14d7
leaq 0xb4c(%rip), %rdi       # 0x201e
callq 0x10d0
jmp 0x14d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/RD.c
// Function: main
int main(int argc, char** argv){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if((strcmp("rd",lines[0])==0)||(strcmp("rmdir",lines[0])==0)){
        for(int i=1;i<argc;i++){
            remove_dir(lines[i]);
        }
    }
    else{
        perror("error after lines\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x30(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1200
movq -0x30(%rbp), %rsi
leaq 0xad1(%rip), %rdi       # 0x2026
callq 0x1080
cmpl $0x0, %eax
je 0x1574
movq -0x30(%rbp), %rsi
leaq 0xabf(%rip), %rdi       # 0x2029
callq 0x1080
cmpl $0x0, %eax
jne 0x15a7
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x15a5
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rdi
callq 0x13a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x157b
jmp 0x15b3
leaq 0xa81(%rip), %rdi       # 0x202f
callq 0x10d0
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/dar-extract_psx.c
// Function: matchhash
unsigned int matchhash( uint32_t hash, uint32_t extension, dicentry *dictionary, int numentries ) {
	int i;
	for( i = 0; i < numentries; i++ ) {
		if((dictionary[i].hash == hash) && (dictionary[i].extension == extension)) return i;
	}
	return 0xFFFFFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1978
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x108, %rcx, %rcx      # imm = 0x108
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x196b
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x108, %rcx, %rcx      # imm = 0x108
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x196b
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x197f
jmp 0x196d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1928
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/dar-extract_psx.c
// Function: getNameFromDetails
char *getNameFromDetails(uint16_t hash, uint16_t extension) {
	char *retstring = malloc(32);
	unsigned int result;
	result = matchhash(hash, extension, commondic, numcommondic);
	if(result != 0xFFFFFFFF) sprintf(retstring, "%s", commondic[result].name);
	else {
		sprintf( retstring, "%04x.%c", hash, extension );
	}
	return retstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x20, %edi
callq 0x1100
movq %rax, -0x10(%rbp)
movzwl -0x2(%rbp), %edi
movzwl -0x4(%rbp), %esi
movq 0x2715(%rip), %rdx      # 0x40d8
movl 0x271f(%rip), %ecx      # 0x40e8
callq 0x1910
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x1a03
movq -0x10(%rbp), %rdi
movq 0x26f6(%rip), %rdx      # 0x40d8
movl -0x14(%rbp), %eax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rdx
addq $0x8, %rdx
leaq 0x71e(%rip), %rsi       # 0x2118
movb $0x0, %al
callq 0x1160
jmp 0x1a1d
movq -0x10(%rbp), %rdi
movzwl -0x2(%rbp), %edx
movzwl -0x4(%rbp), %ecx
leaq 0x705(%rip), %rsi       # 0x211b
movb $0x0, %al
callq 0x1160
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kilobyte[P]colormatch/riemersma-256.c
// Function: main
int main()
{
    for (int c = 0; c < 16777216; ++c)
    {
        nt[c] = closest(c);
        if (!(c&0xff))
            printf("%06X\n", c);
    }

    int fd = creat("riemersma.rgb", 0666);
    write(fd, nt, sizeof(nt));
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1000000, -0x8(%rbp)  # imm = 0x1000000
jge 0x11e2
movl -0x8(%rbp), %edi
callq 0x1220
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0x2eac(%rip), %rax      # 0x4060
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x11d5
movl -0x8(%rbp), %esi
leaq 0xe36(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
jmp 0x11d7
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1196
leaq 0xe21(%rip), %rdi       # 0x200a
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x1070
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x2e60(%rip), %rsi      # 0x4060
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x1040
movl -0xc(%rbp), %edi
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kilobyte[P]colormatch/riemersma-256.c
// Function: closest
static int closest(int rgb)
{
    int best=0, bd = 0x7fffffff;

    for (int i = 0; i < 256; ++i)
    {
        int d = rgb_diff(col256_to_rgb(i), rgb);
        if (d < bd)
            best = i, bd = d;
    }
    return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jge 0x127f
movl -0x10(%rbp), %edi
callq 0x13d0
movl %eax, %edi
movl -0x4(%rbp), %esi
callq 0x1290
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1272
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1274
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1240
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kilobyte[P]colormatch/riemersma-256.c
// Function: rgb_diff
static int rgb_diff(int x, int y)
{
    int rx = x>>16;
    int ry = y>>16;
    int gx = (x>>8)&0xff;
    int gy = (y>>8)&0xff;
    int bx = x&0xff;
    int by = y&0xff;
    int rm = (rx+ry)/2;
    return 2*sqrd(rx, ry)
         + 4*sqrd(gx, gy)
         + 3*sqrd(bx, by)
         + rm*(sqrd(rx, ry)-sqrd(bx, by))/256;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x13a0
shll %eax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x13a0
movl %eax, %ecx
movl -0x38(%rbp), %eax
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x13a0
movl %eax, %ecx
movl -0x34(%rbp), %eax
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x13a0
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x13a0
movl -0x30(%rbp), %ecx
movl %eax, %edx
movl -0x2c(%rbp), %eax
subl %edx, %ecx
imull %ecx, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/storage/storage.c
// Function: screen_init
static void screen_init(int *max_y, int *max_x)
{
  initscr();
  atexit((void *)endwin);
  if (has_colors()) {
    start_color();
    init_pair(1, COLOR_RED,     COLOR_BLACK);
    init_pair(2, COLOR_GREEN,   COLOR_BLACK);
    init_pair(3, COLOR_BLUE,    COLOR_BLACK);
    init_pair(4, COLOR_YELLOW,  COLOR_BLACK);
    init_pair(5, COLOR_MAGENTA, COLOR_BLACK);
    init_pair(6, COLOR_CYAN,    COLOR_BLACK);
    init_pair(7, COLOR_WHITE,   COLOR_BLACK);
  }
  noecho();
  getmaxyx(stdscr, *max_y, *max_x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1090
movq 0x2954(%rip), %rdi      # 0x3ff0
callq 0x1960
callq 0x1030
testb $0x1, %al
jne 0x16ac
jmp 0x1719
callq 0x10b0
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10e0
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10e0
movl $0x3, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x10e0
movl $0x4, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x10e0
movl $0x5, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10e0
movl $0x6, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10e0
movl $0x7, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10e0
callq 0x1080
xorl %eax, %eax
movq 0x28b1(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x1742
movq 0x28a5(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x174c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x174c
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movq 0x287a(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x1779
movq 0x286e(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1783
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x1783
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)