LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		el->used = true;

		// The hard part is now to insert the element in the right place in the list. We could just
		// put it in the front, but this would destroy cache locality during iteration.
		if (firstUsed)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
				if (prevEl->used)
				{
					el->next = prevEl->next;
					prevEl->next = el;
					goto done;
				}
			// We're at the front.
			el->next = firstUsed;
		}
		else
			el->next = nullptr;
		firstUsed = el;
done:
		return &el->data;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x61a88(%rax)
jne 0x6327
movq $0x0, -0x8(%rbp)
jmp 0x63d6
movq -0x28(%rbp), %rax
movq 0x61a88(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x61a88(%rax)
movq -0x18(%rbp), %rcx
movb $0x1, 0x20(%rcx)
cmpq $0x0, 0x61a80(%rax)
je 0x63b3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x20(%rbp)
cmpq %rcx, %rax
jb 0x639e
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x639c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x63ce
jmp 0x635f
movq -0x28(%rbp), %rax
movq 0x61a80(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x63bf
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x61a80(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListBitmapSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		UsedElements.set(el - array);

		// The hard part is now to insert the element in the right place in the list. We could just
		// put it in the front, but this would destroy cache locality during iteration.
		if (firstUsed)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
				if (UsedElements[prevEl - array])
				{
					el->next = prevEl->next;
					prevEl->next = el;
					goto done;
				}
			// We're at the front.
			el->next = firstUsed;
		}
		else
			el->next = nullptr;
		firstUsed = el;
done:
		return &el->data;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x4e208(%rax)
jne 0x6c2b
movq $0x0, -0x8(%rbp)
jmp 0x6d2f
movq -0x38(%rbp), %rax
movq 0x4e208(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x4e208(%rax)
movq %rax, %rdi
addq $0x4e210, %rdi          # imm = 0x4E210
movq -0x18(%rbp), %rsi
subq %rax, %rsi
sarq $0x5, %rsi
movl $0x1, %edx
callq 0x5100
movq -0x38(%rbp), %rax
cmpq $0x0, 0x4e200(%rax)
je 0x6d0c
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x20(%rbp)
cmpq %rcx, %rax
jb 0x6cf7
movq -0x38(%rbp), %rax
movq %rax, %rsi
addq $0x4e210, %rsi          # imm = 0x4E210
movq -0x20(%rbp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
leaq -0x30(%rbp), %rdi
callq 0x5070
leaq -0x30(%rbp), %rdi
callq 0x50b0
movb %al, -0x39(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x50f0
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6cd7
jmp 0x6cf5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x6d27
jmp 0x6c82
movq -0x38(%rbp), %rax
movq 0x4e200(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x6d18
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x4e200(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: DoubleLinkedListSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		el->used = true;

		// The hard part is now to insert the element in the right place in the list. We could just
		// put it in the front, but this would destroy cache locality during iteration.
		if (firstUsed)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
				if (prevEl->used)
				{
					el->next = prevEl->next;
					el->prev = prevEl;
					prevEl->next = el;
					if (el->next)
						el->next->prev = el;
					goto done;
				}
			// We're at the front.
			el->next = firstUsed;
			el->next->prev = el;
		}
		else
			el->next = nullptr;
		firstUsed = el;
		el->prev = nullptr;
done:
		return &el->data;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x75308(%rax)
jne 0x7667
movq $0x0, -0x8(%rbp)
jmp 0x775d
movq -0x28(%rbp), %rax
movq 0x75308(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x75308(%rax)
movq -0x18(%rbp), %rcx
movb $0x1, 0x28(%rcx)
cmpq $0x0, 0x75300(%rax)
je 0x772e
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x20(%rbp)
cmpq %rcx, %rax
jb 0x7709
movq -0x20(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x7707
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7705
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x7755
jmp 0x76a3
movq -0x28(%rbp), %rax
movq 0x75300(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x773a
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x75300(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: DoubleLinkedListSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(el->used);
		el->used = false;

		ListElement *next = el->next;
		if (el == firstUsed)
			firstUsed = next;
		if (next)
			next->prev = el->prev;
		if (el->prev)
			el->prev->next = next;

		if (firstFree)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
			{
				if (!prevEl->used)
				{
					el->next = prevEl->next;
					prevEl->next = el;
					return;
				}
			}
			el->next = firstFree;
		}
		else
			el->next = nullptr;
		firstFree = el;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jb 0x78b6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x75300, %rcx          # imm = 0x75300
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x78bf
jmp 0x78c1
jmp 0x78e0
leaq 0x1ab0(%rip), %rdi      # 0x9378
leaq 0x1825(%rip), %rsi      # 0x90f4
movl $0x2d6, %edx            # imm = 0x2D6
leaq 0x1b6f(%rip), %rcx      # 0x944a
callq 0x20c0
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x78ec
jmp 0x790b
leaq 0x1aeb(%rip), %rdi      # 0x93de
leaq 0x17fa(%rip), %rsi      # 0x90f4
movl $0x2d7, %edx            # imm = 0x2D7
leaq 0x1b44(%rip), %rcx      # 0x944a
callq 0x20c0
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x75300(%rcx), %rax
jne 0x793f
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x75300(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x7956
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7971
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x75308(%rax)
je 0x79db
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x28(%rbp)
cmpq %rcx, %rax
jb 0x79c6
movq -0x28(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x79c4
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x79f6
jmp 0x7987
movq -0x38(%rbp), %rax
movq 0x75308(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x79e7
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x75308(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: UnorderedLinkedListSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		el->used = true;
		// Instead of keeping order, we just prepend the new element to the list.
		el->next = firstUsed;
		firstUsed = el;
		return &el->data;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x61a88(%rax)
jne 0x7f44
movq $0x0, -0x8(%rbp)
jmp 0x7f8c
movq -0x20(%rbp), %rax
movq 0x61a88(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x61a88(%rax)
movq -0x18(%rbp), %rcx
movb $0x1, 0x20(%rcx)
movq 0x61a80(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x61a80(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: UnorderedLinkedListSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(el->used);
		el->used = false;

		ListElement *next = el->next;
		if (el == firstUsed)
			firstUsed = next;
		else
		{
			for (ListElement *prevEl = firstUsed; prevEl; prevEl = prevEl->next)
				if (prevEl->next == el)
				{
					prevEl->next = next;
					break;
				}
		}
		el->next = firstFree;
		firstFree = el;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jb 0x80e6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x61a80, %rcx          # imm = 0x61A80
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x80ef
jmp 0x80f1
jmp 0x8110
leaq 0x1280(%rip), %rdi      # 0x9378
leaq 0xff5(%rip), %rsi       # 0x90f4
movl $0x262, %edx            # imm = 0x262
leaq 0x1389(%rip), %rcx      # 0x9494
callq 0x20c0
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x811c
jmp 0x813b
leaq 0x12bb(%rip), %rdi      # 0x93de
leaq 0xfca(%rip), %rsi       # 0x90f4
movl $0x263, %edx            # imm = 0x263
leaq 0x135e(%rip), %rcx      # 0x9494
callq 0x20c0
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x61a80(%rcx), %rax
jne 0x8171
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x61a80(%rax)
jmp 0x81b5
movq -0x38(%rbp), %rax
movq 0x61a80(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x81b3
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x81a3
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x81b3
jmp 0x81a5
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8180
jmp 0x81b5
movq -0x38(%rbp), %rax
movq 0x61a88(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x61a88(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ReorderingSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		assert(el >= data && el < firstFree);
		auto lastUsed = firstFree - 1;
		if (el != lastUsed)
			*el = std::move(*lastUsed);
		firstFree--;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jb 0x886b
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x30d40(%rcx), %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8874
jmp 0x8876
jmp 0x8895
leaq 0xc64(%rip), %rdi       # 0x94e1
leaq 0x870(%rip), %rsi       # 0x90f4
movl $0x31f, %edx            # imm = 0x31F
leaq 0xc6e(%rip), %rcx       # 0x94fe
callq 0x20c0
movq -0x28(%rbp), %rax
movq 0x30d40(%rax), %rax
addq $-0x14, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x88ce
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x30d40(%rax), %rcx
addq $-0x14, %rcx
movq %rcx, 0x30d40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ReorderingSA<C4PXS, 10000ul>::Iterator<C4PXS, ReorderingSA<C4PXS, 10000ul>>::operator++()
Iterator& operator++()
		{
			// When el is deleted, the next element is the same element.
			if (firstFree != array->firstFree)
				firstFree = array->firstFree;
			else
				el++;
			if (el >= firstFree)
				el = nullptr;
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
cmpq 0x30d40(%rcx), %rax
je 0x8924
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0x30d40(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x8934
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x14, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jb 0x894e
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dekanfrus[P]pThreads/osproj2b.cpp
// Function: fib(void*)
void *fib(void*)
{
	int total;

	// Iterates through and calculates the fibonnaci sequence
	for (int i = 0; i <= num; i++) {
		if (i <= 1) {
			total = i;
		}

		else if (num == 0)
		{
			// Quit the thread if the user's number was 0 as
			// there is nothing to calculate
			pthread_exit(0);
		}
		else
		{
			// Grab the values from the two previous indices
			// add them together and store them in total
			total = fibNum[i-1] + fibNum[i-2];
		}

		// Push the total to the end of the series vector
		fibNum.push_back(total);
	}

	// Exit the thread upon completion
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x2df0(%rip), %eax      # 0x40cc
jg 0x1358
cmpl $0x1, -0x10(%rbp)
jg 0x12ec
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x133a
cmpl $0x0, 0x2dd9(%rip)      # 0x40cc
jne 0x12fe
xorl %eax, %eax
movl %eax, %edi
callq 0x1120
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x2dc2(%rip), %rdi      # 0x40d0
callq 0x1540
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rsi
leaq 0x2da8(%rip), %rdi      # 0x40d0
callq 0x1540
movq %rax, %rcx
movl -0x14(%rbp), %eax
addl (%rcx), %eax
movl %eax, -0xc(%rbp)
jmp 0x133a
leaq 0x2d8f(%rip), %rdi      # 0x40d0
leaq -0xc(%rbp), %rsi
callq 0x1560
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12d3
xorl %eax, %eax
movl %eax, %edi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: dekanfrus[P]pThreads/osproj2b.cpp
// Function: main
int main(int argc, char *argv[]) {

	// Local variable declaration
	pthread_t tid;
	double total = 0;

	// Store arguments into the number variable
	num = atoi(argv[1]);

	// Create a new thread and run the fib function
	pthread_create(&tid, NULL, &fib, NULL);

	// Join the thread to the main process and wait for it to complete
	// before continuing.
	pthread_join(tid, NULL);

	// Display the entire Fibonacci series 
	cout << "Series: " << endl;
	for (int i = 0; i < num; i++)
		cout << fibNum[i] << endl;

	int size = fibNum.size();

	// Display the actual Fibonacci value
	cout << "Total: ";
	total = fibNum[size] + fibNum[size - 1];
	cout << total << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f0
movl %eax, 0x2d2b(%rip)      # 0x40cc
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xf0(%rip), %rdx       # 0x12c0
movq %rcx, %rsi
callq 0x1130
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movq 0x2c0c(%rip), %rdi      # 0x3fd8
leaq 0xc31(%rip), %rsi       # 0x2004
callq 0x10a0
movq %rax, %rdi
movq 0x2be6(%rip), %rsi      # 0x3fc8
callq 0x10d0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x2cd5(%rip), %eax      # 0x40cc
jge 0x1431
movslq -0x24(%rbp), %rsi
leaq 0x2ccc(%rip), %rdi      # 0x40d0
callq 0x1540
movl (%rax), %esi
movq 0x2bc6(%rip), %rdi      # 0x3fd8
callq 0x1110
movq %rax, %rdi
movq 0x2ba7(%rip), %rsi      # 0x3fc8
callq 0x10d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13ee
leaq 0x2c98(%rip), %rdi      # 0x40d0
callq 0x15d0
movl %eax, -0x28(%rbp)
movq 0x2b91(%rip), %rdi      # 0x3fd8
leaq 0xbbf(%rip), %rsi       # 0x200d
callq 0x10a0
movslq -0x28(%rbp), %rsi
leaq 0x2c72(%rip), %rdi      # 0x40d0
callq 0x1540
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x2c58(%rip), %rdi      # 0x40d0
callq 0x1540
movq %rax, %rcx
movl -0x2c(%rbp), %eax
addl (%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0x2b3e(%rip), %rdi      # 0x3fd8
callq 0x1140
movq %rax, %rdi
movq 0x2b1f(%rip), %rsi      # 0x3fc8
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pitzl[P]bobyqa/bobyqa.cc
// Function: print_x(_IO_FILE*, long, double const*, double const*)
static void
print_x( FILE* output, const INTEGER n, const REAL x[], const REAL dx[] )
{
  INTEGER i, k;

  if( output == NULL ) {
    output = stdout;
  }
  for( i = 0; i < n; ++i ) {
    k = i%5;
    if( k == 0 ) {
      fprintf(output, "  ");
    }
    fprintf(output, "%15.6E", (dx == NULL ? x[i] : x[i] + dx[i]));
    if( i == n - 1 || k == 4 ) {
      fprintf(output, "\n");
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xfaaf
movq 0x3529(%rip), %rax      # 0x12fd0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jge 0xfba0
movq 0x20(%rsp), %rax
movl $0x5, %ecx
cqto
idivq %rcx
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xfaf7
movq 0x40(%rsp), %rdi
leaq 0x1823(%rip), %rsi      # 0x11313
movb $0x0, %al
callq 0x1040
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xfb20
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xfb44
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x17b6(%rip), %rsi      # 0x1130c
movb $0x1, %al
callq 0x1040
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0xfb78
cmpq $0x4, 0x18(%rsp)
jne 0xfb8b
movq 0x40(%rsp), %rdi
leaq 0x17b5(%rip), %rsi      # 0x11339
movb $0x0, %al
callq 0x1040
jmp 0xfb8d
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xfab8
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/utils.cpp
// Function: Utils::readFile[abi:cxx11](char const*)
std::string readFile(const char* fileName){
    std::stringstream ss;
    std::ifstream file(fileName,std::ios::binary);
	ss<<file.rdbuf(); // read stream buffer
            
	if(ss.str().empty()){
            throw std::invalid_argument("File Error: Job description file cannot be found or an empty file!");
        }
        
        return ss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rdi, -0x3e0(%rbp)
movq %rdi, %rax
movq %rax, -0x3d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31a0
movq -0x10(%rbp), %rsi
leaq -0x3a0(%rbp), %rdi
movl $0x4, %edx
callq 0x3470
jmp 0x3e87
leaq -0x188(%rbp), %rax
movq %rax, -0x3f0(%rbp)
leaq -0x3a0(%rbp), %rdi
callq 0x33d0
movq %rax, -0x3e8(%rbp)
jmp 0x3eaa
movq -0x3e8(%rbp), %rsi
movq -0x3f0(%rbp), %rdi
callq 0x3080
jmp 0x3ebf
leaq -0x3d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x3ed4
leaq -0x3d0(%rbp), %rdi
callq 0x3420
movb %al, -0x3f1(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x3170
movb -0x3f1(%rbp), %al
testb $0x1, %al
jne 0x3f01
jmp 0x3f8d
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x400(%rbp)
leaq 0x150e9(%rip), %rsi     # 0x19008
callq 0x3490
jmp 0x3f26
movq -0x400(%rbp), %rdi
movq 0x1f0ac(%rip), %rsi     # 0x22fe0
movq 0x1f095(%rip), %rdx     # 0x22fd0
callq 0x3430
jmp 0x3fee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
jmp 0x3fd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
jmp 0x3fca
movq -0x400(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
callq 0x31c0
jmp 0x3fca
movq -0x3e0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x3fa2
leaq -0x3a0(%rbp), %rdi
callq 0x3090
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x3d8(%rbp), %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbp
retq
leaq -0x3a0(%rbp), %rdi
callq 0x3090
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x3a8(%rbp), %rdi
callq 0x3450
nop
// File: MUST-Quick-Fry[P]Process-Scheduler/utils.cpp
// Function: Utils::arg_check(char*)
bool arg_check(char* str){
        try{
            std::string tmp(str);
            int a = std::stoi(tmp);
        }
        catch (std::exception& e){
            throw std::invalid_argument("Arguement Error: Argument is NaN or an overbound number!");
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3460
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3340
jmp 0x4064
leaq -0x29(%rbp), %rdi
callq 0x32a0
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x42c0
movl %eax, -0x5c(%rbp)
jmp 0x4084
movl -0x5c(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3170
jmp 0x4144
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32a0
jmp 0x40c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3170
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x414e
movq -0x38(%rbp), %rdi
callq 0x30d0
movq %rax, -0x48(%rbp)
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x14f53(%rip), %rsi     # 0x1904b
callq 0x3490
jmp 0x40ff
movq -0x68(%rbp), %rdi
movq 0x1eed6(%rip), %rsi     # 0x22fe0
movq 0x1eebf(%rip), %rdx     # 0x22fd0
callq 0x3430
jmp 0x415f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31c0
jmp 0x413b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3410
jmp 0x4142
jmp 0x414e
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3450
movq %rax, %rdi
callq 0x4300
nop
// File: MUST-Quick-Fry[P]Process-Scheduler/monitor.cpp
// Function: Project::Monitor::cmdSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char** Monitor::cmdSplit(std::string str)
{
    //string to char*
    std::vector<std::string> buf;
    std::string tmp;
    std::stringstream ss;
    ss<<str;
    
    while(ss>>tmp)
    {
        buf.push_back(tmp + "");
    }
     
    //char* to char**
    char** pList=new char*[buf.size()];
    for(int i=0; i!=buf.size();i++)
    {
        pList[i]=const_cast<char*>(buf[i].c_str());
    }
    //cout<<pList<<endl;

    //delete[] pList;
    return pList;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rsi, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x68e0
leaq -0x48(%rbp), %rdi
callq 0x3350
leaq -0x1d0(%rbp), %rdi
callq 0x31a0
jmp 0x5cca
movq -0x218(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x3240
jmp 0x5cdf
jmp 0x5ce1
leaq -0x1d0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3310
movq %rax, -0x220(%rbp)
jmp 0x5cfa
movq -0x220(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x221(%rbp)
jmp 0x5d18
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x5d27
jmp 0x5db1
leaq 0x1352e(%rip), %rdx     # 0x1925c
leaq -0x200(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6930
jmp 0x5d40
leaq -0x28(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x6900
jmp 0x5d52
leaq -0x200(%rbp), %rdi
callq 0x3170
jmp 0x5ce1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x5ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x5e96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x3170
jmp 0x5e96
leaq -0x28(%rbp), %rdi
callq 0x69b0
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x230(%rbp)
jmp 0x5dde
movq -0x230(%rbp), %rax
movq %rax, -0x208(%rbp)
movl $0x0, -0x20c(%rbp)
movslq -0x20c(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x69b0
movq %rax, %rcx
movq -0x238(%rbp), %rax
cmpq %rcx, %rax
je 0x5e5a
movslq -0x20c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x69d0
movq %rax, %rdi
callq 0x30e0
movq %rax, %rdx
movq -0x208(%rbp), %rax
movslq -0x20c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20c(%rbp)
jmp 0x5df6
movq -0x208(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3170
leaq -0x28(%rbp), %rdi
callq 0x69f0
movq -0x240(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x1d0(%rbp), %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3170
leaq -0x28(%rbp), %rdi
callq 0x69f0
movq -0x1d8(%rbp), %rdi
callq 0x3450
// File: MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::sig_handler(int)
static void sig_handler(int sig){
        std::cout << std::endl;
        if(sig==SIGTSTP){ 
            std::cout << "\033[34;1mThe Job is suspended ...\033[0m" << std::endl;
            //std::cout << m[getpid()]<< std::endl;
            kill(m[getpid()], SIGTSTP);         
            signal(SIGTSTP, sig_handler);
        }
        else if(sig==SIGCONT){ 
            std::cout << "\033[32;1mThe Job resumes ... \033[0m" << std::endl;
            //std::cout <<m[getpid()] << std::endl;
            kill(m[getpid()], SIGCONT);
            signal(SIGCONT, sig_handler);
        }
        else if(sig==SIGTERM){
            std::cout << "\033[31;1mThe Job terminate ... \033[0m" << std::endl;
            //std::cout <<m[getpid()] << " child " <<std::endl;
            kill(m[getpid()], SIGKILL);
            //signal(SIGTERM, sig_handler);
        }
        
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x1ccde(%rip), %rdi     # 0x22fc0
movq 0x1ccc7(%rip), %rsi     # 0x22fb0
callq 0x3290
cmpl $0x14, -0x4(%rbp)
jne 0x6350
movq 0x1ccc5(%rip), %rdi     # 0x22fc0
leaq 0x12e1a(%rip), %rsi     # 0x1911c
callq 0x3270
movq %rax, %rdi
movq 0x1cc9f(%rip), %rsi     # 0x22fb0
callq 0x3290
callq 0x3390
movl %eax, -0x8(%rbp)
leaq 0x1d48b(%rip), %rdi     # 0x237b0
leaq -0x8(%rbp), %rsi
callq 0x6a50
movl (%rax), %edi
movl $0x14, %esi
callq 0x3360
movl $0x14, %edi
leaq -0x76(%rip), %rsi       # 0x62d0
callq 0x32d0
jmp 0x63ff
cmpl $0x12, -0x4(%rbp)
jne 0x63af
movq 0x1cc63(%rip), %rdi     # 0x22fc0
leaq 0x12ddc(%rip), %rsi     # 0x19140
callq 0x3270
movq %rax, %rdi
movq 0x1cc3d(%rip), %rsi     # 0x22fb0
callq 0x3290
callq 0x3390
movl %eax, -0xc(%rbp)
leaq 0x1d429(%rip), %rdi     # 0x237b0
leaq -0xc(%rbp), %rsi
callq 0x6a50
movl (%rax), %edi
movl $0x12, %esi
callq 0x3360
movl $0x12, %edi
leaq -0xd8(%rip), %rsi       # 0x62d0
callq 0x32d0
jmp 0x63fd
cmpl $0xf, -0x4(%rbp)
jne 0x63fb
movq 0x1cc04(%rip), %rdi     # 0x22fc0
leaq 0x12d9d(%rip), %rsi     # 0x19160
callq 0x3270
movq %rax, %rdi
movq 0x1cbde(%rip), %rsi     # 0x22fb0
callq 0x3290
callq 0x3390
movl %eax, -0x10(%rbp)
leaq 0x1d3ca(%rip), %rdi     # 0x237b0
leaq -0x10(%rbp), %rsi
callq 0x6a50
movl (%rax), %edi
movl $0x9, %esi
callq 0x3360
jmp 0x63fd
jmp 0x63ff
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/monitor.cpp
// Function: Project::Monitor::print_time()
void Monitor::print_time(){
    cout<<"Job Process "<<setw(6)<<get_pid()<<" : Time Elapsed: "<<get_timeElapsed()<<'\n';
    cout<<setfill(' ')<<setw(35)<<"User Time   : "<<get_userTime()<<'\n';
    cout<<setfill(' ')<<setw(35)<<"System Time : "<<get_systemTime()<<'\n';
    cout << "=================================================" << '\n';
    cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x1cb05(%rip), %rdi     # 0x22fc0
leaq 0x12c1d(%rip), %rsi     # 0x190df
callq 0x3270
movq %rax, -0x60(%rbp)
movl $0x6, %edi
callq 0x6a80
movq -0x60(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x32b0
movq -0x30(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x6840
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x3440
movq %rax, %rdi
leaq 0x12be6(%rip), %rsi     # 0x190ec
callq 0x3270
movq -0x30(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x68c0
movq -0x50(%rbp), %rdi
callq 0x34a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x32c0
movl $0x20, %edi
callq 0x6aa0
movb %al, -0xd(%rbp)
movq 0x1ca7e(%rip), %rdi     # 0x22fc0
movzbl -0xd(%rbp), %esi
callq 0x33e0
movq %rax, -0x48(%rbp)
movl $0x23, %edi
callq 0x6a80
movq -0x48(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x32b0
movq %rax, %rdi
leaq 0x12b8c(%rip), %rsi     # 0x190fe
callq 0x3270
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x6880
movq -0x40(%rbp), %rdi
callq 0x34a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x32c0
movl $0x20, %edi
callq 0x6aa0
movb %al, -0x15(%rbp)
movq 0x1ca12(%rip), %rdi     # 0x22fc0
movzbl -0x15(%rbp), %esi
callq 0x33e0
movq %rax, -0x38(%rbp)
movl $0x23, %edi
callq 0x6a80
movq -0x38(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x32b0
movq %rax, %rdi
leaq 0x12b2f(%rip), %rsi     # 0x1910d
callq 0x3270
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x68a0
movq -0x28(%rbp), %rdi
callq 0x34a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x32c0
movq 0x1c9b3(%rip), %rdi     # 0x22fc0
leaq 0x12cef(%rip), %rsi     # 0x19303
callq 0x3270
movq %rax, %rdi
movl $0xa, %esi
callq 0x32c0
movq 0x1c993(%rip), %rdi     # 0x22fc0
movl $0xa, %esi
callq 0x32c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::choosePolicy()
void Scheduler::choosePolicy()
{
    auto cho = policyMap.find(policyInfo);
    if (cho == policyMap.end())
    {
        throw invalid_argument("Invalid policy!");
        exit(-1);
    }
    switch (cho->second)
    {
    case Policy::FIFO:
        /* FIFO function interface*/
        driveFIFO();
        break;
    case Policy::NONPREEMSJF:
        /*non-preetive SJF function interface*/
        driveSJF1();
        break;
    case Policy::PREESJF:
        /*preetive SJF function interface*/
        driveSJF2();
        break;
    case Policy::RR:
        /*RR function interface*/
        driveRR();
        break;
    default:
        throw invalid_argument("Invalid policy!");
        break;
    }
    //cout << *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
addq $0x20, %rdi
callq 0xf670
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x20, %rdi
callq 0xf6d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xf6a0
testb $0x1, %al
jne 0x9138
jmp 0x918b
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1010a(%rip), %rsi     # 0x1925d
callq 0x3490
jmp 0x915a
movq -0x38(%rbp), %rdi
movq 0x19e7b(%rip), %rsi     # 0x22fe0
movq 0x19e64(%rip), %rdx     # 0x22fd0
callq 0x3430
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31c0
jmp 0x9237
leaq -0x10(%rbp), %rdi
callq 0xf700
movl 0x20(%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0x91e1
movq -0x40(%rbp), %rax
leaq 0xfff4(%rip), %rcx      # 0x191a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
callq 0x93d0
jmp 0x9231
movq -0x30(%rbp), %rdi
callq 0x9c40
jmp 0x9231
movq -0x30(%rbp), %rdi
callq 0xa710
jmp 0x9231
movq -0x30(%rbp), %rdi
callq 0xb6f0
jmp 0x9231
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x10061(%rip), %rsi     # 0x1925d
callq 0x3490
jmp 0x9203
movq -0x48(%rbp), %rdi
movq 0x19dd2(%rip), %rsi     # 0x22fe0
movq 0x19dbb(%rip), %rdx     # 0x22fd0
callq 0x3430
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31c0
jmp 0x9237
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3450
// File: MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::find_dur_time(Project::Job, int&)
void Scheduler::find_dur_time(Job j, int& t){
    long tps=sysconf(_SC_CLK_TCK);

    tms start, end;
    clock_t s, e;
    s = times(&start);
    int pID = fork();
    if(pID == 0){ Monitor* monitor = new Monitor(j); exit(0);}
    else{
        waitpid(pID, 0, 0);
        e = times(&end); 
        double realtime = (double)(e-s)/tps;
        
        if(round(realtime)==0){t = 1;}
        else{t= round(realtime);}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, %edi
callq 0x3180
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33f0
movq %rax, -0x68(%rbp)
callq 0x30a0
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jne 0x9340
movl $0xd0, %edi
callq 0x3280
movq -0xf8(%rbp), %rsi
movq %rax, -0x100(%rbp)
movb $0x1, -0xe5(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x5c00
jmp 0x92b8
movq -0x100(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x5ec0
jmp 0x92cd
movb $0x0, -0xe5(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4190
movq -0x100(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %edi, %edi
callq 0x32e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x9324
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4190
testb $0x1, -0xe5(%rbp)
jne 0x932f
jmp 0x933b
movq -0x100(%rbp), %rdi
callq 0x3250
jmp 0x93c0
movl -0x74(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3210
leaq -0x60(%rbp), %rdi
callq 0x33f0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
subq -0x68(%rbp), %rax
cvtsi2sd %rax, %xmm0
cvtsi2sdq -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xf0(%rbp)
movsd -0xf0(%rbp), %xmm0
callq 0x30f0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x939e
jp 0x939e
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x93b5
movsd -0xf0(%rbp), %xmm0
callq 0x30f0
cvttsd2si %xmm0, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x93b7
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_nonpreem(int)
static void signal_nonpreem(int sig){
        
        //std::cout << wait_queue.size() <<std::endl;
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
            
        kill(monitor_map[this_job.ID], SIGTERM);  
        
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_nonpreem);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17493(%rip), %rdi     # 0x23898
callq 0xf8c0
testb $0x1, %al
jne 0xc410
jmp 0xc429
leaq 0x174d1(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xc422
jmp 0xc429
movb $0x1, 0x175cf(%rip)     # 0x239f8
leaq 0x17590(%rip), %rdi     # 0x239c0
leaq 0x173f1(%rip), %rsi     # 0x23828
addq $0x2c, %rsi
callq 0xf920
movl (%rax), %edi
movl $0xf, %esi
callq 0x3360
leaq 0x17495(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xc50e
leaq 0x17481(%rip), %rdi     # 0x238e8
movq %rdi, -0x78(%rbp)
callq 0xf8e0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c00
movq -0x78(%rbp), %rdi
callq 0xf900
jmp 0xc487
leaq -0x34(%rbp), %rsi
leaq 0x1752e(%rip), %rdi     # 0x239c0
callq 0xf920
movq %rax, -0x80(%rbp)
jmp 0xc49d
movq -0x80(%rbp), %rax
movl (%rax), %edi
movl $0x12, %esi
callq 0x3360
leaq 0x17374(%rip), %rdi     # 0x23828
leaq -0x60(%rbp), %rsi
callq 0xf950
jmp 0xc4bf
leaq -0xd6(%rip), %rsi       # 0xc3f0
movl $0xe, %edi
callq 0x32d0
leaq -0x60(%rbp), %rdi
callq 0x5b30
movl %eax, -0x84(%rbp)
jmp 0xc4e1
movl -0x84(%rbp), %edi
callq 0x3480
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xc515
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xc51e
movb $0x1, 0x16d73(%rip)     # 0x23288
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_RR(int)
static void signal_RR(int sig){
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
        
        if(this_job.service_time_left <= QUANT){
            kill(monitor_map[this_job.ID], SIGTERM);  
        }
        else{
            kill(monitor_map[this_job.ID], SIGTSTP);
        }
    
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_RR);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
leaq 0x16d03(%rip), %rdi     # 0x23898
callq 0xf8c0
testb $0x1, %al
jne 0xcba0
jmp 0xcbb9
leaq 0x16d41(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xcbb2
jmp 0xcbb9
movb $0x1, 0x16e3f(%rip)     # 0x239f8
movl 0x16c99(%rip), %eax     # 0x23858
cmpl 0x166c7(%rip), %eax     # 0x2328c
jg 0xcbec
leaq 0x16df2(%rip), %rdi     # 0x239c0
leaq 0x16c53(%rip), %rsi     # 0x23828
addq $0x2c, %rsi
callq 0xf920
movl (%rax), %edi
movl $0xf, %esi
callq 0x3360
jmp 0xcc0f
leaq 0x16dcd(%rip), %rdi     # 0x239c0
leaq 0x16c2e(%rip), %rsi     # 0x23828
addq $0x2c, %rsi
callq 0xf920
movl (%rax), %edi
movl $0x14, %esi
callq 0x3360
leaq 0x16cd2(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xccd1
leaq 0x16cbe(%rip), %rdi     # 0x238e8
movq %rdi, -0x78(%rbp)
callq 0xf8e0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c00
movq -0x78(%rbp), %rdi
callq 0xf900
jmp 0xcc4a
leaq -0x34(%rbp), %rsi
leaq 0x16d6b(%rip), %rdi     # 0x239c0
callq 0xf920
movq %rax, -0x80(%rbp)
jmp 0xcc60
movq -0x80(%rbp), %rax
movl (%rax), %edi
movl $0x12, %esi
callq 0x3360
leaq 0x16bb1(%rip), %rdi     # 0x23828
leaq -0x60(%rbp), %rsi
callq 0xf950
jmp 0xcc82
leaq -0x109(%rip), %rsi      # 0xcb80
movl $0xe, %edi
callq 0x32d0
leaq -0x60(%rbp), %rdi
callq 0x5b30
movl %eax, -0x84(%rbp)
jmp 0xcca4
movl -0x84(%rbp), %edi
callq 0x3480
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xccd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xcce1
movb $0x1, 0x165b0(%rip)     # 0x23288
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_preemSJF(int)
static void signal_preemSJF(int sig){
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
        
        if(this_job.service_time_left == 2){
            kill(monitor_map[this_job.ID], SIGTERM);  
        }
        else{
            kill(monitor_map[this_job.ID], SIGTSTP);
        }
    
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_preemSJF);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
leaq 0x16b53(%rip), %rdi     # 0x23898
callq 0xf8c0
testb $0x1, %al
jne 0xcd50
jmp 0xcd69
leaq 0x16b91(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xcd62
jmp 0xcd69
movb $0x1, 0x16c8f(%rip)     # 0x239f8
cmpl $0x2, 0x16ae8(%rip)     # 0x23858
jne 0xcd97
leaq 0x16c47(%rip), %rdi     # 0x239c0
leaq 0x16aa8(%rip), %rsi     # 0x23828
addq $0x2c, %rsi
callq 0xf920
movl (%rax), %edi
movl $0xf, %esi
callq 0x3360
jmp 0xcdba
leaq 0x16c22(%rip), %rdi     # 0x239c0
leaq 0x16a83(%rip), %rsi     # 0x23828
addq $0x2c, %rsi
callq 0xf920
movl (%rax), %edi
movl $0x14, %esi
callq 0x3360
leaq 0x16b27(%rip), %rdi     # 0x238e8
callq 0xf8c0
testb $0x1, %al
jne 0xce7c
leaq 0x16b13(%rip), %rdi     # 0x238e8
movq %rdi, -0x78(%rbp)
callq 0xf8e0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c00
movq -0x78(%rbp), %rdi
callq 0xf900
jmp 0xcdf5
leaq -0x34(%rbp), %rsi
leaq 0x16bc0(%rip), %rdi     # 0x239c0
callq 0xf920
movq %rax, -0x80(%rbp)
jmp 0xce0b
movq -0x80(%rbp), %rax
movl (%rax), %edi
movl $0x12, %esi
callq 0x3360
leaq 0x16a06(%rip), %rdi     # 0x23828
leaq -0x60(%rbp), %rsi
callq 0xf950
jmp 0xce2d
leaq -0x104(%rip), %rsi      # 0xcd30
movl $0xe, %edi
callq 0x32d0
leaq -0x60(%rbp), %rdi
callq 0x5b30
movl %eax, -0x84(%rbp)
jmp 0xce4f
movl -0x84(%rbp), %edi
callq 0x3480
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xce83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4190
jmp 0xce8c
movb $0x1, 0x16405(%rip)     # 0x23288
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: MUST-Quick-Fry[P]Process-Scheduler/scheduler_main.cpp
// Function: main
int main(int argc, char * argv[]){
    if(argc!=3){
        throw invalid_argument("The number of arguments of Scheduler is nonstandard!");
    }
    Scheduler sc(argv[1],argv[2]);   
    //cout<<sc; 
    //sc.Display();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x18e48
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0x5b3(%rip), %rsi       # 0x193c0
callq 0x3490
jmp 0x18e14
movq -0xa0(%rbp), %rdi
movq 0xa1be(%rip), %rsi      # 0x22fe0
movq 0xa1a7(%rip), %rdx      # 0x22fd0
callq 0x3430
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31c0
jmp 0x18e83
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq -0x98(%rbp), %rdi
callq 0x86c0
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x18e90
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: blak3mill3r[P]mouser/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
  Mouser xlib_loop;

  fiber xevent_fiber(  [&](){ xlib_loop.xevent_handler();  });
  fiber keyboard_fiber([&](){ xlib_loop.key_handler();     });
  fiber physics_fiber( [&](){ xlib_loop.physics_handler(); });
  fiber xtest_fiber(   [&](){ xlib_loop.xtest_handler();   });

  xlib_loop.run();
  xevent_fiber.join();
  keyboard_fiber.join();
  xtest_fiber.join();
  physics_fiber.join();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x168(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0xbb20
movq -0x1c0(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x48d0
jmp 0x471f
leaq -0x168(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x4920
jmp 0x4742
leaq -0x168(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x4970
jmp 0x4765
leaq -0x168(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x49c0
jmp 0x4788
leaq -0x168(%rbp), %rdi
callq 0xbdd0
jmp 0x4796
leaq -0x170(%rbp), %rdi
callq 0x4340
jmp 0x47a4
leaq -0x190(%rbp), %rdi
callq 0x4340
jmp 0x47b2
leaq -0x1b0(%rbp), %rdi
callq 0x4340
jmp 0x47c0
leaq -0x1a0(%rbp), %rdi
callq 0x4340
jmp 0x47ce
movl $0x0, -0x4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x82e0
leaq -0x1a0(%rbp), %rdi
callq 0x82e0
leaq -0x190(%rbp), %rdi
callq 0x82e0
leaq -0x170(%rbp), %rdi
callq 0x82e0
leaq -0x168(%rbp), %rdi
callq 0xbd10
movl -0x4(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x48af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x48a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x4897
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x488b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x82e0
leaq -0x1a0(%rbp), %rdi
callq 0x82e0
leaq -0x190(%rbp), %rdi
callq 0x82e0
leaq -0x170(%rbp), %rdi
callq 0x82e0
leaq -0x168(%rbp), %rdi
callq 0xbd10
movq -0x180(%rbp), %rdi
callq 0x44d0
nopw (%rax,%rax)