LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Create new chunk if necessary.
			if (!Chunk[i])
			{
				Chunk[i] = new T[ChunkSize];
				ChunkFill[i] = 0;
			}
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq $0x0, (%rbx,%rbp,8)
jne 0x2f2a
movl $0x2710, %edi           # imm = 0x2710
callq 0x1030
movq %rax, %r15
movl $0x2710, %edx           # imm = 0x2710
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %r15, (%rbx,%rbp,8)
movq $0x0, 0xa0(%rbx,%rbp,8)
cmpq $0x1f3, 0xa0(%rbx,%rbp,8) # imm = 0x1F3
ja 0x2fde
imulq $0x1f4, %rbp, %rdx      # imm = 0x1F4
movq %rdx, %rax
shrq $0x6, %rax
movq 0x140(%rbx,%rax,8), %rdi
movl $0x1, %r8d
movl %edx, %ecx
shlq %cl, %r8
btq %rdx, %rdi
jae 0x2fa9
xorl %esi, %esi
cmpq $0x1f3, %rsi            # imm = 0x1F3
je 0x2fd7
leaq (%r12,%rsi), %rcx
movq %rcx, %rax
movl $0x1, %r8d
shlq %cl, %r8
shrq $0x6, %rax
movq 0x140(%rbx,%rax,8), %rdi
incq %rsi
btq %rcx, %rdi
jb 0x2f65
leaq -0x1(%rsi), %rcx
cmpq $0x1f3, %rcx            # imm = 0x1F3
setae %cl
movq %rsi, %rdx
subq %r13, %rdx
jmp 0x2fad
xorl %ecx, %ecx
xorl %esi, %esi
cmpq $0x2710, %rdx           # imm = 0x2710
jae 0x300e
orq %r8, %rdi
movq %rdi, 0x140(%rbx,%rax,8)
incq 0xa0(%rbx,%rbp,8)
leaq (%rsi,%rsi,4), %r14
shlq $0x2, %r14
addq (%rbx,%rbp,8), %r14
jmp 0x2fda
setae %cl
testb %cl, %cl
je 0x2ffc
incq %rbp
addq $-0x1f4, %r13           # imm = 0xFE0C
addq $0x1f4, %r12            # imm = 0x1F4
cmpq $0x14, %rbp
jne 0x2ef7
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2268(%rip), %rdi      # 0x527d
leaq 0x2255(%rip), %rsi      # 0x5271
movl $0x2710, %ecx           # imm = 0x2710
xorl %eax, %eax
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		if (--ChunkFill[i] == 0)
		{
			delete[] Chunk[i];
			Chunk[i] = nullptr;
		}
	}

// Assembly:
pushq %rbx
xorl %ecx, %ecx
movq %rdi, %rbx
cmpq $0x0, 0xa0(%rbx)
je 0x3054
movq (%rbx), %rax
cmpq %rsi, %rax
setbe %dl
leaq 0x2710(%rax), %r8
cmpq %rsi, %r8
seta %r8b
testb %r8b, %dl
jne 0x3087
addq $0x8, %rbx
addq $-0x1f4, %rcx           # imm = 0xFE0C
cmpq $-0x2710, %rcx          # imm = 0xD8F0
jne 0x302e
leaq 0x2242(%rip), %rdi      # 0x52b1
leaq 0x2096(%rip), %rsi      # 0x510c
leaq 0x2241(%rip), %rcx      # 0x52be
movl $0x92, %edx
callq 0x1080
subq %rax, %rsi
sarq $0x2, %rsi
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rsi, %rax
subq %rcx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq 0x140(%rdi,%rcx,8), %rcx
btq %rax, %rcx
jae 0x30e2
addq $0x140, %rdi            # imm = 0x140
movq %rax, %rsi
callq 0x31aa
decq 0xa0(%rbx)
jne 0x30e0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30d9
callq 0x1110
movq $0x0, (%rbx)
popq %rbx
retq
leaq 0x2225(%rip), %rdi      # 0x530e
leaq 0x201c(%rip), %rsi      # 0x510c
leaq 0x21c7(%rip), %rcx      # 0x52be
movl $0x95, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Iterator<C4PXS, ChunkSA<C4PXS, 10000ul, 500ul>>::next(bool)
Iterator& next(bool return_next)
		{
			for (; i < MaxChunk; i++, j = 0)
			{
				if (array->ChunkFill[i])
				{
					for (; j < ChunkSize; j++)
					{
						if (array->UsedElements[i*ChunkSize + j] && return_next)
							return *this;
						return_next = true;
					}
				}
				return_next = true;
			}
			// We're at the end.
			array = nullptr;
			i = j = 0;
			return *this;
		}

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdx
cmpq $0x13, %rdx
ja 0x319a
movq (%rax), %rdi
movq 0x10(%rax), %r9
imulq $0x1f4, %rdx, %r8       # imm = 0x1F4
cmpq $0x0, 0xa0(%rdi,%rdx,8)
setne %cl
cmpq $0x1f4, %r9             # imm = 0x1F4
setb %r10b
andb %cl, %r10b
cmpb $0x1, %r10b
jne 0x3175
leaq (%r8,%r9), %rcx
movl $0x1, %r10d
shlq %cl, %r10
testb $0x1, %sil
je 0x3162
shrq $0x6, %rcx
andq 0x140(%rdi,%rcx,8), %r10
jne 0x31a8
incq %r9
movq %r9, 0x10(%rax)
movb $0x1, %sil
cmpq $0x1f4, %r9             # imm = 0x1F4
jne 0x3141
incq %rdx
movq %rdx, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x1f4, %r8             # imm = 0x1F4
movb $0x1, %sil
movl $0x0, %r9d
cmpq $0x14, %rdx
jne 0x3121
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x1f3, 0x30d40(%rdi,%r9,8) # imm = 0x1F3
ja 0x34bc
imulq $0x1f4, %r9, %rdx       # imm = 0x1F4
movq %rdx, %r10
shrq $0x6, %r10
movq 0x30de0(%rdi,%r10,8), %rbx
movl $0x1, %r14d
movl %edx, %ecx
shlq %cl, %r14
btq %rdx, %rbx
jae 0x3480
xorl %r11d, %r11d
cmpq $0x1f3, %r11            # imm = 0x1F3
je 0x34b5
leaq (%rsi,%r11), %rcx
movq %rcx, %r10
movl $0x1, %r14d
shlq %cl, %r14
shrq $0x6, %r10
movq 0x30de0(%rdi,%r10,8), %rbx
incq %r11
btq %rcx, %rbx
jb 0x343d
leaq -0x1(%r11), %rax
cmpq $0x1f3, %rax            # imm = 0x1F3
setae %cl
movq %r11, %rdx
subq %r8, %rdx
jmp 0x3485
xorl %ecx, %ecx
xorl %r11d, %r11d
cmpq $0x2710, %rdx           # imm = 0x2710
jae 0x34e1
orq %r14, %rbx
movq %rbx, 0x30de0(%rdi,%r10,8)
incq 0x30d40(%rdi,%r9,8)
imulq $0x2710, %r9, %rax      # imm = 0x2710
addq %rdi, %rax
leaq (%r11,%r11,4), %rdx
leaq (%rax,%rdx,4), %rax
jmp 0x34b8
setae %cl
testb %cl, %cl
je 0x34d9
incq %r9
addq $-0x1f4, %r8            # imm = 0xFE0C
addq $0x1f4, %rsi            # imm = 0x1F4
cmpq $0x14, %r9
jne 0x3401
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d95(%rip), %rdi      # 0x527d
leaq 0x1d82(%rip), %rsi      # 0x5271
movl $0x2710, %ecx           # imm = 0x2710
xorl %eax, %eax
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		--ChunkFill[i];
	}

// Assembly:
pushq %rbx
leaq 0x30d40(%rdi), %rbx
movq %rsi, %rax
subq %rdi, %rax
xorl %ecx, %ecx
movq $-0x2710, %rdx          # imm = 0xD8F0
movq %rdi, %r8
cmpq $0x0, (%rbx)
je 0x3536
cmpq %rsi, %r8
setbe %r9b
leaq 0x2710(%r8), %r10
cmpq %rsi, %r10
seta %r10b
testb %r10b, %r9b
jne 0x356f
addq $0x8, %rbx
addq $-0x1f4, %rcx           # imm = 0xFE0C
addq %rdx, %rax
addq $0x2710, %r8            # imm = 0x2710
cmpq %rdx, %rcx
jne 0x3516
leaq 0x1d5a(%rip), %rdi      # 0x52b1
leaq 0x1bae(%rip), %rsi      # 0x510c
leaq 0x1dd5(%rip), %rcx      # 0x533a
movl $0xfb, %edx
callq 0x1080
sarq $0x2, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
subq %rcx, %rsi
movq %rsi, %rax
shrq $0x6, %rax
movq 0x30de0(%rdi,%rax,8), %rax
btq %rsi, %rax
jae 0x35aa
addq $0x30de0, %rdi          # imm = 0x30DE0
callq 0x31aa
decq (%rbx)
popq %rbx
retq
leaq 0x1d5d(%rip), %rdi      # 0x530e
leaq 0x1b54(%rip), %rsi      # 0x510c
leaq 0x1d7b(%rip), %rcx      # 0x533a
movl $0xfe, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListSA<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;
		bool lookingForUsed = false, lookingForFree = !!firstFree;
		if (el == firstUsed)
			firstUsed = next;
		else
			lookingForUsed = true;

		ListElement *prevEl = el;
		while (--prevEl >= array && (lookingForUsed || lookingForFree))
		{
			if (lookingForUsed && prevEl->used)
			{
				prevEl->next = next;
				lookingForUsed = false;
			}
			if (lookingForFree && !prevEl->used)
			{
				el->next = prevEl->next;
				prevEl->next = el;
				lookingForFree = false;
			}
		}

		if (!!firstFree == lookingForFree)
		{
			if (firstFree)
				el->next = firstFree;
			else
				el->next = nullptr;
			firstFree = el;
		}
	}

// Assembly:
pushq %rax
cmpq %rdi, %rsi
jb 0x3983
leaq 0x61a80(%rdi), %r9
cmpq %rsi, %r9
jbe 0x3983
cmpb $0x0, 0x20(%rsi)
je 0x39a2
movb $0x0, 0x20(%rsi)
movq 0x18(%rsi), %rdx
movq 0x61a88(%rdi), %rax
testq %rax, %rax
setne %cl
movb $0x1, %r8b
cmpq %rsi, 0x61a80(%rdi)
jne 0x3921
movq %rdx, (%r9)
xorl %r8d, %r8d
leaq -0x28(%rsi), %r9
cmpq %rdi, %r9
jb 0x3969
testb $0x1, %r8b
jne 0x3935
testb $0x1, %cl
je 0x3969
testb $0x1, %r8b
je 0x3949
cmpb $0x1, 0x20(%r9)
jne 0x3949
movq %rdx, 0x18(%r9)
xorl %r8d, %r8d
testb $0x1, %cl
je 0x3963
cmpb $0x0, 0x20(%r9)
jne 0x3963
movq 0x18(%r9), %rcx
movq %rcx, 0x18(%rsi)
movq %rsi, 0x18(%r9)
xorl %ecx, %ecx
addq $-0x28, %r9
jmp 0x3925
testq %rax, %rax
setne %dl
xorb %cl, %dl
testb $0x1, %dl
jne 0x3981
movq %rax, 0x18(%rsi)
movq %rsi, 0x61a88(%rdi)
popq %rax
retq
leaq 0x1a06(%rip), %rdi      # 0x5390
leaq 0x177b(%rip), %rsi      # 0x510c
leaq 0x1a1a(%rip), %rcx      # 0x53b2
movl $0x175, %edx            # imm = 0x175
callq 0x1080
leaq 0x1a4d(%rip), %rdi      # 0x53f6
leaq 0x175c(%rip), %rsi      # 0x510c
leaq 0x19fb(%rip), %rcx      # 0x53b2
movl $0x176, %edx            # imm = 0x176
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq 0x4e208(%rdi), %rax
testq %rax, %rax
je 0x3c55
movq 0x18(%rax), %rcx
movq %rcx, 0x4e208(%rdi)
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq $0x2710, %rdx           # imm = 0x2710
jae 0x3c75
movl $0x1, %esi
movl %edx, %ecx
shlq %cl, %rsi
shrq $0x6, %rdx
orq %rsi, 0x4e210(%rdi,%rdx,8)
movq 0x4e200(%rdi), %rcx
testq %rcx, %rcx
je 0x3c59
leaq -0x20(%rax), %r8
movq %r8, %rsi
subq %rdi, %rsi
movq %r8, %rdx
cmpq %rdi, %r8
jb 0x3c63
movq %rsi, %r9
sarq $0x5, %r9
movq %r9, %r8
shrq $0x6, %r8
movq 0x4e210(%rdi,%r8,8), %r10
leaq -0x20(%rdx), %r8
addq $-0x20, %rsi
btq %r9, %r10
jae 0x3c1b
movq 0x38(%r8), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x38(%r8)
jmp 0x3c67
xorl %eax, %eax
jmp 0x3c73
movq $0x0, 0x18(%rax)
jmp 0x3c6c
movq %rcx, 0x18(%rax)
cmpq %rdi, %rdx
jae 0x3c73
movq %rax, 0x4e200(%rdi)
popq %rcx
retq
leaq 0x1601(%rip), %rdi      # 0x527d
leaq 0x15ee(%rip), %rsi      # 0x5271
movl $0x2710, %ecx           # imm = 0x2710
xorl %eax, %eax
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O1/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListBitmapSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(UsedElements[el - array]);
		UsedElements.reset(el - array);

		ListElement *next = el->next;
		bool lookingForUsed = false, lookingForFree = !!firstFree;
		if (el == firstUsed)
			firstUsed = next;
		else
			lookingForUsed = true;

		ListElement *prevEl = el;
		while (--prevEl >= array && (lookingForUsed || lookingForFree))
		{
			if (lookingForUsed && UsedElements[prevEl - array])
			{
				prevEl->next = next;
				lookingForUsed = false;
			}
			if (lookingForFree && !UsedElements[prevEl - array])
			{
				el->next = prevEl->next;
				prevEl->next = el;
				lookingForFree = false;
			}
		}

		if (!!firstFree == lookingForFree)
		{
			if (firstFree)
				el->next = firstFree;
			else
				el->next = nullptr;
			firstFree = el;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
subq %rdi, %r12
jb 0x3da3
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e200(%rdi), %r13
cmpq %rsi, %r13
jbe 0x3da3
movq %r12, %rsi
sarq $0x5, %rsi
movq %rsi, %rax
shrq $0x6, %rax
movq 0x4e210(%r14,%rax,8), %rax
btq %rsi, %rax
jae 0x3dc2
leaq 0x4e210(%r14), %r15
movq %r15, %rdi
callq 0x31aa
movq 0x18(%rbx), %rdx
movq 0x4e208(%r14), %rax
testq %rax, %rax
setne %cl
movb $0x1, %sil
cmpq %rbx, 0x4e200(%r14)
jne 0x3d0d
movq %rdx, (%r13)
xorl %esi, %esi
leaq -0x20(%rbx), %rdi
cmpq %r14, %rdi
jb 0x3d81
addq $-0x20, %r12
testb $0x1, %sil
jne 0x3d25
testb $0x1, %cl
je 0x3d81
testb $0x1, %sil
je 0x3d49
movq %r12, %r8
sarq $0x5, %r8
movq %r8, %r9
shrq $0x6, %r9
movq (%r15,%r9,8), %r9
btq %r8, %r9
jae 0x3d49
movq %rdx, 0x18(%rdi)
xorl %esi, %esi
testb $0x1, %cl
je 0x3d74
movq %r12, %r8
sarq $0x5, %r8
movq %r8, %r9
shrq $0x6, %r9
movq (%r15,%r9,8), %r9
btq %r8, %r9
jb 0x3d74
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%rbx)
movq %rbx, 0x18(%rdi)
xorl %ecx, %ecx
addq $-0x20, %rdi
addq $-0x20, %r12
cmpq %r14, %rdi
jae 0x3d1a
testq %rax, %rax
setne %dl
xorb %cl, %dl
testb $0x1, %dl
jne 0x3d99
movq %rax, 0x18(%rbx)
movq %rbx, 0x4e208(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x15e6(%rip), %rdi      # 0x5390
leaq 0x135b(%rip), %rsi      # 0x510c
leaq 0x1647(%rip), %rcx      # 0x53ff
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x1080
leaq 0x1680(%rip), %rdi      # 0x5449
leaq 0x133c(%rip), %rsi      # 0x510c
leaq 0x1628(%rip), %rcx      # 0x53ff
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x75308(%rdi), %rax
testq %rax, %rax
je 0x4025
movq 0x18(%rax), %rcx
movq %rcx, 0x75308(%rdi)
movb $0x1, 0x28(%rax)
movq 0x75300(%rdi), %rcx
testq %rcx, %rcx
je 0x4028
movq %rax, %rsi
leaq -0x30(%rsi), %rdx
cmpq %rdi, %rdx
jb 0x4032
cmpb $0x1, -0x8(%rsi)
movq %rdx, %rsi
jne 0x3ff8
movq 0x18(%rdx), %rcx
movq %rcx, 0x18(%rax)
movq %rdx, 0x20(%rax)
movq %rax, 0x18(%rdx)
movq 0x18(%rax), %rcx
testq %rcx, %rcx
jne 0x4036
jmp 0x403a
xorl %eax, %eax
retq
movq $0x0, 0x18(%rax)
jmp 0x403f
movq %rcx, 0x18(%rax)
movq %rax, 0x20(%rcx)
cmpq %rdi, %rdx
jae 0x4027
movq %rax, 0x75300(%rdi)
movq $0x0, 0x20(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
cmpq %rdi, %rsi
jb 0x40ea
leaq 0x75300(%rdi), %rcx
cmpq %rsi, %rcx
jbe 0x40ea
cmpb $0x0, 0x28(%rsi)
je 0x4109
movb $0x0, 0x28(%rsi)
movq 0x18(%rsi), %rax
cmpq %rsi, (%rcx)
jne 0x4084
movq %rax, (%rcx)
testq %rax, %rax
je 0x4091
movq 0x20(%rsi), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rsi), %rcx
testq %rcx, %rcx
je 0x409e
movq %rax, 0x18(%rcx)
movq 0x75308(%rdi), %rax
testq %rax, %rax
je 0x40ce
leaq -0x30(%rsi), %rdx
movq %rdx, %rcx
cmpq %rdi, %rdx
jb 0x40d8
leaq -0x30(%rcx), %rdx
cmpb $0x0, 0x28(%rcx)
jne 0x40ae
movq 0x48(%rdx), %rax
movq %rax, 0x18(%rsi)
movq %rsi, 0x48(%rdx)
jmp 0x40dc
movq $0x0, 0x18(%rsi)
jmp 0x40e1
movq %rax, 0x18(%rsi)
cmpq %rdi, %rcx
jae 0x40e8
movq %rsi, 0x75308(%rdi)
popq %rax
retq
leaq 0x129f(%rip), %rdi      # 0x5390
leaq 0x1014(%rip), %rsi      # 0x510c
leaq 0x1363(%rip), %rcx      # 0x5462
movl $0x2d6, %edx            # imm = 0x2D6
callq 0x1080
leaq 0x12e6(%rip), %rdi      # 0x53f6
leaq 0xff5(%rip), %rsi       # 0x510c
leaq 0x1344(%rip), %rcx      # 0x5462
movl $0x2d7, %edx            # imm = 0x2D7
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
cmpq %rdi, %rsi
jb 0x43a2
leaq 0x61a80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x43a2
cmpb $0x0, 0x20(%rsi)
je 0x43c1
movb $0x0, 0x20(%rsi)
movq 0x18(%rsi), %rcx
movq (%rax), %rdx
cmpq %rsi, %rdx
je 0x438b
testq %rdx, %rdx
je 0x438e
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rsi, %rdx
jne 0x4376
addq $0x18, %rax
movq %rcx, (%rax)
movq 0x61a88(%rdi), %rax
movq %rax, 0x18(%rsi)
movq %rsi, 0x61a88(%rdi)
popq %rax
retq
leaq 0xfe7(%rip), %rdi       # 0x5390
leaq 0xd5c(%rip), %rsi       # 0x510c
leaq 0x10f5(%rip), %rcx      # 0x54ac
movl $0x262, %edx            # imm = 0x262
callq 0x1080
leaq 0x102e(%rip), %rdi      # 0x53f6
leaq 0xd3d(%rip), %rsi       # 0x510c
leaq 0x10d6(%rip), %rcx      # 0x54ac
movl $0x263, %edx            # imm = 0x263
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x2de8(%rip), %eax      # 0x40c4
testl %eax, %eax
js 0x134e
xorl %r15d, %r15d
leaq 0x2dde(%rip), %rbx      # 0x40c8
leaq -0x1c(%rbp), %r14
cmpq $0x1, %r15
ja 0x12f9
movl %r15d, %eax
jmp 0x130e
testl %eax, %eax
je 0x134e
movq 0x2dc4(%rip), %rcx      # 0x40c8
movl -0x8(%rcx,%r15,4), %eax
addl -0x4(%rcx,%r15,4), %eax
movl %eax, -0x1c(%rbp)
movq 0x2db8(%rip), %rsi      # 0x40d0
cmpq 0x2db9(%rip), %rsi      # 0x40d8
je 0x1330
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x2da2(%rip)      # 0x40d0
jmp 0x133b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x14e4
leaq 0x1(%r15), %rcx
movslq 0x2d7e(%rip), %rax      # 0x40c4
cmpq %rax, %r15
movq %rcx, %r15
jl 0x12ee
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdi
callq 0x10f0
movl %eax, 0x2d56(%rip)      # 0x40c4
leaq -0xa9(%rip), %rdx       # 0x12cc
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1140
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1090
movq 0x2c42(%rip), %rbx      # 0x3fd8
leaq 0xc67(%rip), %rsi       # 0x2004
movl $0x8, %edx
movq %rbx, %rdi
callq 0x10d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
cmpl $0x0, 0x2cec(%rip)      # 0x40c4
jle 0x1430
xorl %r15d, %r15d
movq 0x2bf4(%rip), %rbx      # 0x3fd8
movq 0x2cdd(%rip), %rax      # 0x40c8
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x1120
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
incq %r15
movslq 0x2c99(%rip), %rax      # 0x40c4
cmpq %rax, %r15
jl 0x13e4
movq 0x2c99(%rip), %r14      # 0x40d0
subq 0x2c8a(%rip), %r14      # 0x40c8
movq 0x2b93(%rip), %rbx      # 0x3fd8
leaq 0xbc1(%rip), %rsi       # 0x200d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x10d0
shlq $0x1e, %r14
movq 0x2c64(%rip), %rax      # 0x40c8
movq %r14, %rcx
sarq $0x1e, %rcx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %r14, %rdx
sarq $0x1e, %rdx
movl (%rax,%rdx), %edx
addl (%rax,%rcx), %edx
cvtsi2sd %edx, %xmm0
movq %rbx, %rdi
callq 0x1100
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
testq %rdi, %rdi
jne 0x8bf4
movq 0x33df(%rip), %rax      # 0xbfd0
movq (%rax), %r12
testq %r15, %r15
jle 0x8c98
leaq -0x1(%r15), %r14
xorl %r13d, %r13d
movq %r13, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq %rdx, %rbp
shrq $0x2, %rbp
leaq (,%rbp,4), %rax
addq %rbp, %rax
cmpq %r13, %rax
jne 0x8c44
movl $0x2, %esi
movl $0x1, %edx
leaq 0x1737(%rip), %rdi      # 0xa373
movq %r12, %rcx
callq 0x1070
movq (%rsp), %rax
movsd (%rax,%r13,8), %xmm0
testq %rbx, %rbx
je 0x8c59
addsd (%rbx,%r13,8), %xmm0
leaq 0x4(%rbp,%rbp,4), %rbp
movq %r12, %rdi
leaq 0x1704(%rip), %rsi      # 0xa36c
movb $0x1, %al
callq 0x1060
cmpq %r13, %r14
setne %al
cmpq %r13, %rbp
setne %cl
testb %cl, %al
jne 0x8c8c
movl $0xa, %edi
movq %r12, %rsi
callq 0x1050
incq %r13
cmpq %r13, %r15
jne 0x8c04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x21a0
leaq -0x3c8(%rbp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x2400
leaq -0x1b0(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x2080
leaq -0x1a8(%rbp), %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2370
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x30ce
callq 0x2250
testq %r15, %r15
je 0x311a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2370
leaq -0x3c8(%rbp), %rdi
callq 0x2090
movq 0x11ebf(%rip), %rsi     # 0x14fb0
leaq -0x1c0(%rbp), %rdi
callq 0x21e0
leaq -0x140(%rbp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2130
movq %rax, %r14
leaq 0xced6(%rip), %rsi      # 0x10004
movq %rax, %rdi
callq 0x2420
movq 0x11ea3(%rip), %rsi     # 0x14fe0
movq 0x11e8c(%rip), %rdx     # 0x14fd0
movq %r14, %rdi
callq 0x23c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x21d0
jmp 0x3163
jmp 0x3160
movq %rax, %rbx
jmp 0x316f
movq %rax, %rbx
leaq -0x3c8(%rbp), %rdi
callq 0x2090
movq 0x11e3a(%rip), %rsi     # 0x14fb0
leaq -0x1c0(%rbp), %rdi
callq 0x21e0
leaq -0x140(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x20e0
movq -0x48(%rbp), %rbx
callq 0x2050
movq %rax, %r14
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2300
cmpq %rbx, (%r15)
je 0x323c
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x3248
movl (%r14), %eax
cmpl $0x22, %eax
je 0x3248
testl %eax, %eax
jne 0x321b
movl %r12d, (%r14)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322d
callq 0x2250
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce3d(%rip), %rdi      # 0x10080
callq 0x2170
leaq 0xce31(%rip), %rdi      # 0x10080
callq 0x2320
movq %rdx, %r15
movq %rax, %rbx
jmp 0x327d
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x326b
movl %r12d, (%r14)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x327d
callq 0x2250
cmpl $0x1, %r15d
jne 0x32d2
movq %rbx, %rdi
callq 0x20f0
movl $0x10, %edi
callq 0x2130
movq %rax, %r14
leaq 0xcda8(%rip), %rsi      # 0x10047
movq %rax, %rdi
callq 0x2420
movq 0x11d32(%rip), %rsi     # 0x14fe0
movq 0x11d1b(%rip), %rdx     # 0x14fd0
movq %r14, %rdi
callq 0x23c0
movq %rax, %rbx
jmp 0x32cd
movq %rax, %rbx
movq %r14, %rdi
callq 0x21d0
callq 0x23b0
movq %rbx, %rdi
callq 0x23e0
movq %rax, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
xorl %eax, %eax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x208(%rbp), %rdi
callq 0x21a0
leaq -0x1f8(%rbp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x22a0
leaq -0x70(%rbp), %rbx
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
leaq 0xc9a9(%rip), %r12      # 0x1029b
leaq -0x40(%rbp), %r13
leaq -0x208(%rbp), %rdi
movq %r14, %rsi
callq 0x22e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3950
movq %rbx, -0x80(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37c8
movq %r15, %rdi
movq %r12, %rsi
callq 0x2430
movq %r13, %rdi
movq %r15, %rsi
callq 0x4798
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x38f6
callq 0x2250
jmp 0x38f6
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r12
movq %r12, %rax
subq %r14, %rax
movq %rax, %r15
sarq $0x5, %r15
movq %r15, %rcx
shrq $0x3d, %rcx
sarq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, %rbx
cmpq %r14, %r12
je 0x399d
xorl %eax, %eax
movq (%r14), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
addq $0x20, %r14
cmpq %rax, %r15
jne 0x398a
movq 0x1160c(%rip), %rsi     # 0x14fb0
leaq -0x208(%rbp), %rdi
callq 0x21e0
leaq -0x188(%rbp), %rdi
callq 0x20c0
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x39ce
callq 0x2250
leaq -0x40(%rbp), %rdi
callq 0x4456
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a0c
jmp 0x3a0c
movq %rax, %r14
jmp 0x3a32
jmp 0x39f7
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3a0f
callq 0x2250
jmp 0x3a0f
jmp 0x3a0c
movq %rax, %r14
movq 0x1159a(%rip), %rsi     # 0x14fb0
leaq -0x208(%rbp), %rdi
callq 0x21e0
leaq -0x188(%rbp), %rdi
callq 0x20c0
leaq -0x50(%rbp), %r15
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a40
callq 0x2250
leaq -0x40(%rbp), %rdi
callq 0x4456
movq %r14, %rdi
callq 0x23e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %r14d
movq 0x1119a(%rip), %rbx     # 0x14fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
cmpl $0xf, %r14d
je 0x3f4c
cmpl $0x12, %r14d
je 0x3edb
cmpl $0x14, %r14d
jne 0x3faa
leaq 0xc2cc(%rip), %rsi      # 0x10142
movl $0x23, %edx
movq %rbx, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
callq 0x2340
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
leaq 0x118a4(%rip), %rdi     # 0x15760
callq 0x44a4
movl (%rax), %edi
movl $0x14, %esi
callq 0x2310
leaq -0xbb(%rip), %rsi       # 0x3e19
movl $0x14, %edi
jmp 0x3f45
leaq 0xc284(%rip), %rsi      # 0x10166
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
callq 0x2340
leaq -0x18(%rbp), %rsi
movl %eax, (%rsi)
leaq 0x11838(%rip), %rdi     # 0x15760
callq 0x44a4
movl (%rax), %edi
movl $0x12, %esi
callq 0x2310
leaq -0x127(%rip), %rsi      # 0x3e19
movl $0x12, %edi
callq 0x22b0
jmp 0x3faa
leaq 0xc233(%rip), %rsi      # 0x10186
movl $0x21, %edx
movq %rbx, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
callq 0x2340
leaq -0x14(%rbp), %rsi
movl %eax, (%rsi)
leaq 0x117c7(%rip), %rdi     # 0x15760
callq 0x44a4
movl (%rax), %edi
movl $0x9, %esi
callq 0x2310
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10f70(%rip), %rbx     # 0x14fc8
leaq 0xc0a6(%rip), %rsi      # 0x10105
movl $0xc, %edx
movq %rbx, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x6, 0x10(%rbx,%rax)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x23d0
movq %rax, %r15
leaq 0xc080(%rip), %rsi      # 0x10112
movl $0x11, %edx
movq %rax, %rdi
callq 0x22a0
movsd 0x70(%r14), %xmm0
movq %r15, %rdi
callq 0x2380
leaq -0x19(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x40f2
movq %r15, %rdi
movl $0x20, %esi
callq 0x2260
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x20, 0xe0(%r15)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x23, 0x10(%rbx,%rax)
leaq 0xc013(%rip), %rsi      # 0x10124
movl $0xe, %edx
movq %rbx, %rdi
callq 0x22a0
movsd 0x60(%r14), %xmm0
movq %rbx, %rdi
callq 0x2380
leaq -0x1a(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x4171
movq %r15, %rdi
movl $0x20, %esi
callq 0x2260
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x20, 0xe0(%r15)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x23, 0x10(%rbx,%rax)
leaq 0xbfa3(%rip), %rsi      # 0x10133
movl $0xe, %edx
movq %rbx, %rdi
callq 0x22a0
movsd 0x68(%r14), %xmm0
movq %rbx, %rdi
callq 0x2380
movb $0xa, %r14b
leaq -0x1b(%rbp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x22a0
leaq 0xc179(%rip), %rsi      # 0x10342
movl $0x31, %edx
movq %rbx, %rdi
callq 0x22a0
leaq -0x1c(%rbp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x22a0
leaq -0x1d(%rbp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x22a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::normalizeCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scheduler::normalizeCheck(string cont)
{

    int arg_num = 0;

    for (int i = 0; i < cont.length(); ++i)
    {
        if (cont[i] == '\n')
        {

            if (cont[i - 1] == '\n')
            {
                if (cont[i - 2] == '\t')
                {
                    throw invalid_argument("Argument Error: Empty argument!");
                }
                continue;
            }

            if (cont[i - 1] == '\t')
            {
                throw invalid_argument("Argument Error: Empty argument!");
            }

            arg_num++;
            if (arg_num > 3)
            {
                throw invalid_argument("Argument Error: Job description file has redundant arguments!");
            }
            if (arg_num < 3)
            {
                throw invalid_argument("Argument Error: Job description file has less arguments!");
            }
            arg_num = 0;
        }
        if (cont[i] == '\t')
        {
            arg_num++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x4d77
movq (%rsi), %rcx
xorl %edx, %edx
xorl %esi, %esi
movb (%rcx,%rdx), %dil
cmpb $0xa, %dil
jne 0x4d58
movzbl -0x1(%rcx,%rdx), %r8d
cmpl $0xa, %r8d
je 0x4d68
cmpl $0x9, %r8d
je 0x4db8
cmpl $0x3, %esi
jge 0x4d9a
cmpl $0x2, %esi
movl $0x0, %esi
jne 0x4d7c
xorl %r8d, %r8d
cmpb $0x9, %dil
sete %r8b
addl %r8d, %esi
jmp 0x4d6f
cmpb $0x9, -0x2(%rcx,%rdx)
je 0x4dd6
incq %rdx
cmpq %rdx, %rax
jne 0x4d2d
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb4d0(%rip), %rsi      # 0x10260
movq %rax, %rdi
callq 0x2420
jmp 0x4df2
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb474(%rip), %rsi      # 0x10222
movq %rax, %rdi
callq 0x2420
jmp 0x4df2
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb436(%rip), %rsi      # 0x10202
movq %rax, %rdi
callq 0x2420
jmp 0x4df2
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb418(%rip), %rsi      # 0x10202
movq %rax, %rdi
callq 0x2420
movq 0x101e7(%rip), %rsi     # 0x14fe0
movq 0x101d0(%rip), %rdx     # 0x14fd0
movq %rbx, %rdi
callq 0x23c0
jmp 0x4e0e
jmp 0x4e0e
jmp 0x4e0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x23e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xd6f6
testq %rax, %rax
je 0x51b4
movl 0x28(%rax), %eax
cmpq $0x3, %rax
ja 0x51e6
leaq 0xb049(%rip), %rcx      # 0x101c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x533a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6512
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x72aa
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5b4c
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb0d4(%rip), %rsi      # 0x1029c
movq %rax, %rdi
callq 0x2420
movq 0xfe09(%rip), %rsi      # 0x14fe0
movq 0xfdf2(%rip), %rdx      # 0x14fd0
movq %rbx, %rdi
callq 0x23c0
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0xb0a2(%rip), %rsi      # 0x1029c
movq %rax, %rdi
callq 0x2420
jmp 0x51d0
jmp 0x5206
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x23e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl $0x2, %edi
callq 0x2180
movq %rax, %r15
leaq -0xb8(%rbp), %rdi
callq 0x2390
movq %rax, %r12
callq 0x20a0
testl %eax, %eax
je 0x52ad
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
leaq -0x98(%rbp), %rdi
callq 0x2390
subq %r12, %rax
cvtsi2sd %rax, %xmm0
cvtsi2sd %r15, %xmm1
divsd %xmm1, %xmm0
callq 0x2100
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl $0x1, %ecx
cmovnel %eax, %ecx
cmovpl %eax, %ecx
movl %ecx, (%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xd0, %edi
callq 0x2280
movq %rax, %rbx
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x37c8
movq 0x4e(%r14), %rax
leaq -0x78(%rbp), %rsi
movq %rax, 0x4e(%rsi)
movups 0x20(%r14), %xmm0
movups 0x30(%r14), %xmm1
movups 0x40(%r14), %xmm2
movups %xmm2, 0x40(%rsi)
movups %xmm1, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movq %rbx, %rdi
callq 0x3a52
leaq -0x78(%rbp), %rdi
callq 0x32e2
xorl %edi, %edi
callq 0x22c0
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x532a
callq 0x2250
jmp 0x532a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0xdb05(%rip), %rax      # 0x15878
cmpq 0xdade(%rip), %rax      # 0x15858
jne 0x7d93
movq 0xdb45(%rip), %rax      # 0x158c8
cmpq 0xdb1e(%rip), %rax      # 0x158a8
jne 0x7d93
movb $0x1, 0xdc15(%rip)      # 0x159a8
leaq 0xdbd6(%rip), %rdi      # 0x15970
leaq 0xda63(%rip), %rsi      # 0x15804
callq 0xcdb0
movl (%rax), %edi
movl $0xf, %esi
callq 0x2310
movq 0xdaef(%rip), %r15      # 0x158a8
cmpq %r15, 0xdb08(%rip)      # 0x158c8
je 0x7e9f
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x37c8
movq 0x4e(%r15), %rax
movq %rax, 0x4e(%rbx)
movups 0x20(%r15), %xmm0
movups 0x30(%r15), %xmm1
movups 0x40(%r15), %xmm2
movups %xmm2, 0x40(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
leaq 0xda8a(%rip), %rdi      # 0x15898
callq 0xce58
leaq -0x44(%rbp), %rsi
leaq 0xdb52(%rip), %rdi      # 0x15970
callq 0xcdb0
movl (%rax), %edi
movl $0x12, %esi
callq 0x2310
leaq 0xd9a2(%rip), %rdi      # 0x157d8
leaq -0x70(%rbp), %rsi
callq 0x2150
leaq -0x50(%rbp), %rax
movq 0x2e(%rax), %rcx
movq %rcx, 0xd9d8(%rip)      # 0x15826
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0xd9b8(%rip)     # 0x15818
movups %xmm1, 0xd9a1(%rip)     # 0x15808
movups %xmm0, 0xd98a(%rip)     # 0x157f8
leaq -0x116(%rip), %rsi      # 0x7d5f
movl $0xe, %edi
callq 0x22b0
leaq -0x70(%rbp), %rdi
callq 0x3746
movl %eax, %edi
callq 0x2410
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x7ea6
callq 0x2250
jmp 0x7ea6
movb $0x0, 0xdb03(%rip)      # 0x159a9
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x7ec2
callq 0x2250
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0xd430(%rip), %rax      # 0x15878
cmpq 0xd409(%rip), %rax      # 0x15858
jne 0x8468
movq 0xd470(%rip), %rax      # 0x158c8
cmpq 0xd449(%rip), %rax      # 0x158a8
jne 0x8468
movb $0x1, 0xd540(%rip)      # 0x159a8
xorl %ebx, %ebx
cmpl $0x3, 0xd397(%rip)      # 0x15808
setge %bl
leaq 0xd4f5(%rip), %rdi      # 0x15970
leaq 0xd382(%rip), %rsi      # 0x15804
callq 0xcdb0
movl (%rax), %edi
leal (%rbx,%rbx,4), %esi
addl $0xf, %esi
callq 0x2310
movq 0xd40d(%rip), %r15      # 0x158a8
cmpq %r15, 0xd426(%rip)      # 0x158c8
je 0x8581
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x37c8
movq 0x4e(%r15), %rax
movq %rax, 0x4e(%rbx)
movups 0x20(%r15), %xmm0
movups 0x30(%r15), %xmm1
movups 0x40(%r15), %xmm2
movups %xmm2, 0x40(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
leaq 0xd3a8(%rip), %rdi      # 0x15898
callq 0xce58
leaq -0x44(%rbp), %rsi
leaq 0xd470(%rip), %rdi      # 0x15970
callq 0xcdb0
movl (%rax), %edi
movl $0x12, %esi
callq 0x2310
leaq 0xd2c0(%rip), %rdi      # 0x157d8
leaq -0x70(%rbp), %rsi
callq 0x2150
leaq -0x50(%rbp), %rax
movq 0x2e(%rax), %rcx
movq %rcx, 0xd2f6(%rip)      # 0x15826
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0xd2d6(%rip)     # 0x15818
movups %xmm1, 0xd2bf(%rip)     # 0x15808
movups %xmm0, 0xd2a8(%rip)     # 0x157f8
leaq -0x123(%rip), %rsi      # 0x8434
movl $0xe, %edi
callq 0x22b0
leaq -0x70(%rbp), %rdi
callq 0x3746
movl %eax, %edi
callq 0x2410
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x8588
callq 0x2250
jmp 0x8588
movb $0x0, 0xd421(%rip)      # 0x159a9
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x85a4
callq 0x2250
movq %rbx, %rdi
callq 0x23e0